sync-worktrees 1.8.0 → 2.1.0

package/dist/index.js

@@ -1,231 +1,3358 @@
 #!/usr/bin/env node
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
+
+// src/index.ts
+import * as path8 from "path";
+import { confirm as confirm2 } from "@inquirer/prompts";
+import * as cron2 from "node-cron";
+import pLimit2 from "p-limit";
+
+// src/constants.ts
+var GIT_CONSTANTS = {
+  REMOTE_PREFIX: "origin/",
+  REMOTE_NAME: "origin",
+  HEAD_REF: "/HEAD",
+  DEFAULT_BRANCH: "main",
+  COMMON_DEFAULT_BRANCHES: ["main", "master", "develop", "trunk"],
+  BARE_DIR_NAME: ".bare",
+  DIVERGED_DIR_NAME: ".diverged",
+  LFS_HEADER: "version https://git-lfs.github.com/spec/",
+  SUBMODULE_STATUS_ADDED: "+",
+  SUBMODULE_STATUS_REMOVED: "-",
+  GITDIR_PREFIX: "gitdir:",
+  GIT_CHECK_IGNORE_NO_MATCH: "exit code: 1",
+  REFS: {
+    HEADS: "refs/heads/",
+    REMOTES: "refs/remotes/origin",
+    REMOTES_ORIGIN: "refs/remotes/origin/*"
+  },
+  FETCH_CONFIG: "+refs/heads/*:refs/remotes/origin/*"
+};
+var GIT_OPERATIONS = {
+  MERGE_HEAD: "MERGE_HEAD",
+  CHERRY_PICK_HEAD: "CHERRY_PICK_HEAD",
+  REVERT_HEAD: "REVERT_HEAD",
+  BISECT_LOG: "BISECT_LOG",
+  REBASE_MERGE: "rebase-merge",
+  REBASE_APPLY: "rebase-apply"
+};
+var DEFAULT_CONFIG = {
+  CRON_SCHEDULE: "0 * * * *",
+  RETRY: {
+    MAX_ATTEMPTS: 3,
+    MAX_LFS_RETRIES: 2,
+    INITIAL_DELAY_MS: 1e3,
+    MAX_DELAY_MS: 3e4,
+    BACKOFF_MULTIPLIER: 2,
+    JITTER_MS: 500
+  },
+  PARALLELISM: {
+    MAX_REPOSITORIES: 2,
+    MAX_WORKTREE_CREATION: 1,
+    MAX_WORKTREE_UPDATES: 3,
+    MAX_WORKTREE_REMOVAL: 3,
+    MAX_STATUS_CHECKS: 20,
+    MAX_SAFE_TOTAL_CONCURRENT_OPS: 100
+  },
+  UPDATE_EXISTING_WORKTREES: true
+};
+var ERROR_MESSAGES = {
+  GIT_NOT_INITIALIZED: "Git service not initialized. Call initialize() first.",
+  ALREADY_EXISTS: "already exists",
+  ALREADY_REGISTERED: "already registered worktree",
+  FAST_FORWARD_FAILED: [
+    "Not possible to fast-forward",
+    "fatal: Not possible to fast-forward, aborting",
+    "cannot fast-forward"
+  ],
+  NO_UPSTREAM: [
+    "fatal: no upstream configured",
+    "no upstream configured for branch",
+    "fatal: ambiguous argument",
+    "unknown revision or path"
+  ],
+  LFS_ERROR: ["smudge filter lfs failed", "git-lfs", "LFS"],
+  EXDEV: "EXDEV"
+};
+var ENV_CONSTANTS = {
+  GIT_LFS_SKIP_SMUDGE: "GIT_LFS_SKIP_SMUDGE",
+  NODE_ENV_TEST: "test"
+};
+var PATH_CONSTANTS = {
+  GIT_DIR: ".git",
+  README: "README"
+};
+var CONFIG_CONSTANTS = {
+  WILDCARD_PATTERN: ".*"
+};
+var METADATA_CONSTANTS = {
+  MAX_HISTORY_ENTRIES: 10,
+  METADATA_FILENAME: "sync-metadata.json",
+  WORKTREE_METADATA_PATH: ".git/worktrees",
+  DIVERGED_INFO_FILE: ".diverged-info.json",
+  DIVERGED_REASON: "diverged-history-with-changes",
+  ACTION_CREATED: "created",
+  ACTION_UPDATED: "updated",
+  ACTION_FETCHED: "fetched"
+};
+
+// src/services/config-loader.service.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { pathToFileURL } from "url";
+var ConfigLoaderService = class {
+  async loadConfigFile(configPath) {
+    const absolutePath = path.resolve(configPath);
+    try {
+      await fs.access(absolutePath);
+    } catch {
+      throw new Error(`Config file not found: ${absolutePath}`);
+    }
+    try {
+      const fileUrl = pathToFileURL(absolutePath);
+      fileUrl.searchParams.set("t", Date.now().toString());
+      const configModule = await import(fileUrl.href);
+      const config = configModule.default;
+      if (!config) {
+        throw new Error("Config file must use 'export default' syntax");
+      }
+      this.validateConfigFile(config);
+      return config;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Config file not found")) {
+        throw error;
+      }
+      throw new Error(`Failed to load config file: ${error.message}`);
+    }
+  }
+  validateConfigFile(config) {
+    if (!config || typeof config !== "object") {
+      throw new Error("Config file must export an object");
+    }
+    const configObj = config;
+    if (!Array.isArray(configObj.repositories)) {
+      throw new Error("Config file must have a 'repositories' array");
+    }
+    if (configObj.repositories.length === 0) {
+      throw new Error("Config file must have at least one repository");
+    }
+    const seenNames = /* @__PURE__ */ new Set();
+    configObj.repositories.forEach((repo, index) => {
+      if (!repo || typeof repo !== "object") {
+        throw new Error(`Repository at index ${index} must be an object`);
+      }
+      const repoObj = repo;
+      if (!repoObj.name || typeof repoObj.name !== "string") {
+        throw new Error(`Repository at index ${index} must have a 'name' property`);
+      }
+      if (seenNames.has(repoObj.name)) {
+        throw new Error(`Duplicate repository name: ${repoObj.name}`);
+      }
+      seenNames.add(repoObj.name);
+      if (!repoObj.repoUrl || typeof repoObj.repoUrl !== "string") {
+        throw new Error(`Repository '${repoObj.name}' must have a 'repoUrl' property`);
+      }
+      if (!repoObj.worktreeDir || typeof repoObj.worktreeDir !== "string") {
+        throw new Error(`Repository '${repoObj.name}' must have a 'worktreeDir' property`);
+      }
+      if (repoObj.bareRepoDir !== void 0 && typeof repoObj.bareRepoDir !== "string") {
+        throw new Error(`Repository '${repoObj.name}' has invalid 'bareRepoDir' property`);
+      }
+      if (repoObj.cronSchedule !== void 0 && typeof repoObj.cronSchedule !== "string") {
+        throw new Error(`Repository '${repoObj.name}' has invalid 'cronSchedule' property`);
+      }
+      if (repoObj.runOnce !== void 0 && typeof repoObj.runOnce !== "boolean") {
+        throw new Error(`Repository '${repoObj.name}' has invalid 'runOnce' property`);
+      }
+    });
+    if (configObj.defaults) {
+      if (typeof configObj.defaults !== "object") {
+        throw new Error("'defaults' must be an object");
+      }
+      const defaults = configObj.defaults;
+      if (defaults.cronSchedule !== void 0 && typeof defaults.cronSchedule !== "string") {
+        throw new Error("Invalid 'cronSchedule' in defaults");
+      }
+      if (defaults.runOnce !== void 0 && typeof defaults.runOnce !== "boolean") {
+        throw new Error("Invalid 'runOnce' in defaults");
+      }
+      if (defaults.retry !== void 0 && typeof defaults.retry !== "object") {
+        throw new Error("Invalid 'retry' in defaults");
+      }
+    }
+    if (configObj.retry !== void 0) {
+      if (typeof configObj.retry !== "object") {
+        throw new Error("'retry' must be an object");
+      }
+      const retry2 = configObj.retry;
+      if (retry2.maxAttempts !== void 0) {
+        if (retry2.maxAttempts !== "unlimited" && (typeof retry2.maxAttempts !== "number" || retry2.maxAttempts < 1)) {
+          throw new Error("Invalid 'maxAttempts' in retry config. Must be 'unlimited' or a positive number");
+        }
+      }
+      if (retry2.maxLfsRetries !== void 0) {
+        if (typeof retry2.maxLfsRetries !== "number" || retry2.maxLfsRetries < 0) {
+          throw new Error("Invalid 'maxLfsRetries' in retry config. Must be a non-negative number");
+        }
+      }
+      if (retry2.initialDelayMs !== void 0 && (typeof retry2.initialDelayMs !== "number" || retry2.initialDelayMs < 0)) {
+        throw new Error("Invalid 'initialDelayMs' in retry config");
+      }
+      if (retry2.maxDelayMs !== void 0 && (typeof retry2.maxDelayMs !== "number" || retry2.maxDelayMs < 0)) {
+        throw new Error("Invalid 'maxDelayMs' in retry config");
+      }
+      if (retry2.backoffMultiplier !== void 0 && (typeof retry2.backoffMultiplier !== "number" || retry2.backoffMultiplier < 1)) {
+        throw new Error("Invalid 'backoffMultiplier' in retry config");
+      }
+    }
+    if (configObj.parallelism !== void 0) {
+      this.validateParallelismConfig(configObj.parallelism, "global");
+    }
+    if (configObj.defaults && typeof configObj.defaults === "object") {
+      const defaults = configObj.defaults;
+      if (defaults.parallelism !== void 0) {
+        this.validateParallelismConfig(defaults.parallelism, "defaults");
+      }
+    }
+  }
+  validateParallelismConfig(parallelism, context) {
+    if (typeof parallelism !== "object" || parallelism === null) {
+      throw new Error(`'parallelism' in ${context} must be an object`);
+    }
+    const config = parallelism;
+    if (config.maxRepositories !== void 0) {
+      if (typeof config.maxRepositories !== "number" || config.maxRepositories < 1) {
+        throw new Error(`Invalid 'maxRepositories' in ${context} parallelism config. Must be a positive number`);
+      }
+    }
+    if (config.maxWorktreeCreation !== void 0) {
+      if (typeof config.maxWorktreeCreation !== "number" || config.maxWorktreeCreation < 1) {
+        throw new Error(`Invalid 'maxWorktreeCreation' in ${context} parallelism config. Must be a positive number`);
+      }
+    }
+    if (config.maxWorktreeUpdates !== void 0) {
+      if (typeof config.maxWorktreeUpdates !== "number" || config.maxWorktreeUpdates < 1) {
+        throw new Error(`Invalid 'maxWorktreeUpdates' in ${context} parallelism config. Must be a positive number`);
+      }
+    }
+    if (config.maxWorktreeRemoval !== void 0) {
+      if (typeof config.maxWorktreeRemoval !== "number" || config.maxWorktreeRemoval < 1) {
+        throw new Error(`Invalid 'maxWorktreeRemoval' in ${context} parallelism config. Must be a positive number`);
+      }
+    }
+    if (config.maxStatusChecks !== void 0) {
+      if (typeof config.maxStatusChecks !== "number" || config.maxStatusChecks < 1) {
+        throw new Error(`Invalid 'maxStatusChecks' in ${context} parallelism config. Must be a positive number`);
+      }
+    }
+    const maxRepos = config.maxRepositories ?? DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES;
+    const maxCreation = config.maxWorktreeCreation ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_CREATION;
+    const maxUpdates = config.maxWorktreeUpdates ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_UPDATES;
+    const maxRemoval = config.maxWorktreeRemoval ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_REMOVAL;
+    const maxStatus = config.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS;
+    const maxPerRepoOps = maxCreation + maxUpdates + maxRemoval + maxStatus;
+    const totalMaxConcurrent = maxRepos * maxPerRepoOps;
+    if (totalMaxConcurrent > DEFAULT_CONFIG.PARALLELISM.MAX_SAFE_TOTAL_CONCURRENT_OPS) {
+      const safeMaxRepos = Math.floor(DEFAULT_CONFIG.PARALLELISM.MAX_SAFE_TOTAL_CONCURRENT_OPS / maxPerRepoOps);
+      throw new Error(
+        `Total concurrent operations (${totalMaxConcurrent}) exceeds safe limit (${DEFAULT_CONFIG.PARALLELISM.MAX_SAFE_TOTAL_CONCURRENT_OPS}). With current per-repository limits (creation: ${maxCreation}, updates: ${maxUpdates}, removal: ${maxRemoval}, status: ${maxStatus}), maximum safe maxRepositories is ${safeMaxRepos}. Consider reducing maxRepositories or lowering per-operation limits.`
+      );
+    }
+  }
+  resolveRepositoryConfig(repo, defaults, configDir, globalRetry) {
+    const resolved = {
+      name: repo.name,
+      repoUrl: repo.repoUrl,
+      worktreeDir: this.resolvePath(repo.worktreeDir, configDir),
+      cronSchedule: repo.cronSchedule ?? defaults?.cronSchedule ?? DEFAULT_CONFIG.CRON_SCHEDULE,
+      runOnce: repo.runOnce ?? defaults?.runOnce ?? false
+    };
+    if (repo.bareRepoDir) {
+      resolved.bareRepoDir = this.resolvePath(repo.bareRepoDir, configDir);
+    }
+    if (repo.branchMaxAge || defaults?.branchMaxAge) {
+      resolved.branchMaxAge = repo.branchMaxAge ?? defaults?.branchMaxAge;
+    }
+    if (repo.skipLfs !== void 0 || defaults?.skipLfs !== void 0) {
+      resolved.skipLfs = repo.skipLfs ?? defaults?.skipLfs ?? false;
+    }
+    if (repo.retry || defaults?.retry || globalRetry) {
+      resolved.retry = {
+        ...globalRetry || {},
+        ...defaults?.retry || {},
+        ...repo.retry || {}
+      };
+    }
+    if (repo.parallelism || defaults?.parallelism) {
+      resolved.parallelism = {
+        ...defaults?.parallelism || {},
+        ...repo.parallelism || {}
+      };
+    }
+    if (repo.updateExistingWorktrees !== void 0 || defaults?.updateExistingWorktrees !== void 0) {
+      resolved.updateExistingWorktrees = repo.updateExistingWorktrees ?? defaults?.updateExistingWorktrees ?? true;
+    }
+    return resolved;
+  }
+  resolvePath(inputPath, baseDir) {
+    if (path.isAbsolute(inputPath)) {
+      return inputPath;
+    }
+    return path.resolve(baseDir || process.cwd(), inputPath);
+  }
+  filterRepositories(repositories, filter) {
+    if (!filter) {
+      return repositories;
+    }
+    const patterns = filter.split(",").map((p) => p.trim());
+    return repositories.filter((repo) => {
+      return patterns.some((pattern) => {
+        if (pattern.includes("*")) {
+          const regex = new RegExp("^" + pattern.replace(/\*/g, CONFIG_CONSTANTS.WILDCARD_PATTERN) + "$");
+          return regex.test(repo.name);
+        }
+        return repo.name === pattern;
+      });
+    });
+  }
+};
+
+// src/services/InteractiveUIService.tsx
+import React4 from "react";
+import { render } from "ink";
+import * as cron from "node-cron";
+
+// src/components/App.tsx
+import React3, { useState as useState2, useEffect as useEffect2, useCallback } from "react";
+import { Box as Box3, useInput as useInput2 } from "ink";
+
+// src/components/StatusBar.tsx
+import React, { useState, useEffect } from "react";
+import { Box, Text } from "ink";
+import { CronExpressionParser } from "cron-parser";
+var StatusBar = ({ status, repositoryCount, lastSyncTime, cronSchedule, diskSpaceUsed }) => {
+  const [nextSyncTime, setNextSyncTime] = useState(null);
+  useEffect(() => {
+    if (!cronSchedule) {
+      setNextSyncTime(null);
+      return void 0;
+    }
+    try {
+      const interval = CronExpressionParser.parse(cronSchedule);
+      setNextSyncTime(interval.next().toDate());
+      const timer = setInterval(() => {
+        const nextInterval = CronExpressionParser.parse(cronSchedule);
+        setNextSyncTime(nextInterval.next().toDate());
+      }, 6e4);
+      return () => clearInterval(timer);
+    } catch (error) {
+      setNextSyncTime(null);
+      return void 0;
+    }
+  }, [cronSchedule]);
+  const formatTime = (date) => {
+    if (!date) return "N/A";
+    return date.toLocaleTimeString();
+  };
+  const getStatusColor = () => {
+    return status === "syncing" ? "yellow" : "green";
+  };
+  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...")))));
+};
+var StatusBar_default = StatusBar;
+
+// src/components/HelpModal.tsx
+import React2 from "react";
+import { Box as Box2, Text as Text2, useInput } from "ink";
+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"))));
+};
+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);
+  useInput2((input2, key) => {
+    if (showHelp) {
+      if (input2 === "?" || input2 === "h") {
+        setShowHelp(false);
+      }
+      return;
+    }
+    if (key.escape || input2 === "q") {
+      void onQuit();
+    } else if (input2 === "?" || input2 === "h") {
+      setShowHelp(true);
+    } else if (input2 === "s" && status !== "syncing") {
+      setStatus("syncing");
+      void (async () => {
+        try {
+          await onManualSync();
+        } catch (error) {
+          console.error("Manual sync failed:", error);
+          setStatus("idle");
+        }
+      })();
+    } else if (input2 === "r" && status !== "syncing") {
+      setStatus("syncing");
+      void (async () => {
+        try {
+          await onReload();
+        } catch (error) {
+          console.error("Reload failed:", error);
+          setStatus("idle");
+        }
+      })();
+    }
+  });
+  const updateLastSyncTime = useCallback(() => {
+    setLastSyncTime(/* @__PURE__ */ new Date());
+    setStatus("idle");
+  }, []);
+  useEffect2(() => {
+    globalThis.__inkAppMethods = {
+      updateLastSyncTime,
+      setStatus,
+      setDiskSpace: setDiskSpaceUsed
     };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
+    return () => {
+      delete globalThis.__inkAppMethods;
     };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = __importStar(require("path"));
-const prompts_1 = require("@inquirer/prompts");
-const cron = __importStar(require("node-cron"));
-const config_loader_service_1 = require("./services/config-loader.service");
-const worktree_sync_service_1 = require("./services/worktree-sync.service");
-const cli_1 = require("./utils/cli");
-const interactive_1 = require("./utils/interactive");
-async function runSingleRepository(config) {
-    console.log("\n📋 CLI Command (for future reference):");
-    console.log(`   ${(0, cli_1.reconstructCliCommand)(config)}`);
-    console.log("");
-    const syncService = new worktree_sync_service_1.WorktreeSyncService(config);
+  }, [updateLastSyncTime, setStatus]);
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(
+    StatusBar_default,
+    {
+      status,
+      repositoryCount,
+      lastSyncTime,
+      cronSchedule,
+      diskSpaceUsed: diskSpaceUsed ?? void 0
+    }
+  ), showHelp && /* @__PURE__ */ React3.createElement(HelpModal_default, { onClose: () => setShowHelp(false) }));
+};
+var App_default = App;
+
+// src/services/worktree-sync.service.ts
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
+import pLimit from "p-limit";
+
+// src/utils/date-filter.ts
+function parseDuration(durationStr) {
+  const match = durationStr.match(/^(\d+)([hdwmy])$/);
+  if (!match) {
+    return null;
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const multipliers = {
+    h: 60 * 60 * 1e3,
+    // hours
+    d: 24 * 60 * 60 * 1e3,
+    // days
+    w: 7 * 24 * 60 * 60 * 1e3,
+    // weeks
+    m: 30 * 24 * 60 * 60 * 1e3,
+    // months (approximate)
+    y: 365 * 24 * 60 * 60 * 1e3
+    // years (approximate)
+  };
+  return value * multipliers[unit];
+}
+function filterBranchesByAge(branches, maxAge) {
+  const maxAgeMs = parseDuration(maxAge);
+  if (maxAgeMs === null) {
+    console.warn(`Invalid duration format: ${maxAge}. Using all branches.`);
+    return branches;
+  }
+  const cutoffDate = new Date(Date.now() - maxAgeMs);
+  return branches.filter(({ lastActivity }) => lastActivity >= cutoffDate);
+}
+function formatDuration(durationStr) {
+  const match = durationStr.match(/^(\d+)([hdwmy])$/);
+  if (!match) {
+    return durationStr;
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const unitNames = {
+    h: value === 1 ? "hour" : "hours",
+    d: value === 1 ? "day" : "days",
+    w: value === 1 ? "week" : "weeks",
+    m: value === 1 ? "month" : "months",
+    y: value === 1 ? "year" : "years"
+  };
+  return `${value} ${unitNames[unit]}`;
+}
+
+// src/utils/lfs-error.ts
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  return String(error);
+}
+var LFS_ERROR_PATTERNS = Object.freeze([
+  "smudge filter lfs failed",
+  "Object does not exist on the server",
+  "external filter 'git-lfs filter-process' failed"
+]);
+function isLfsError(errorMessage) {
+  return LFS_ERROR_PATTERNS.some((pattern) => errorMessage.includes(pattern));
+}
+function isLfsErrorFromError(error) {
+  return isLfsError(getErrorMessage(error));
+}
+
+// src/utils/retry.ts
+var DEFAULT_OPTIONS = {
+  maxAttempts: "unlimited",
+  maxLfsRetries: 2,
+  initialDelayMs: 1e3,
+  maxDelayMs: 6e5,
+  // 10 minutes
+  backoffMultiplier: 2,
+  jitterMs: 0,
+  shouldRetry: (error, context) => {
+    const err = error;
+    if (isLfsErrorFromError(error)) {
+      if (context) {
+        context.isLfsError = true;
+      }
+      return true;
+    }
+    if (err.code === "ENOTFOUND" || err.code === "ECONNREFUSED" || err.code === "ETIMEDOUT") {
+      return true;
+    }
+    if (err.code === "EBUSY" || err.code === "ENOENT" || err.code === "EACCES") {
+      return true;
+    }
+    if (err.message?.includes("Could not read from remote repository")) {
+      return true;
+    }
+    if (err.message?.includes("fatal: unable to access")) {
+      return true;
+    }
+    return false;
+  },
+  onRetry: () => {
+  },
+  lfsRetryHandler: (_context) => {
+  }
+};
+async function retry(fn, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let attempt = 1;
+  let lfsAttempt = 0;
+  const lfsContext = { isLfsError: false };
+  while (true) {
     try {
-        await syncService.initialize();
-        if (config.runOnce) {
-            console.log("Running the sync process once as requested by --runOnce flag.");
-            await syncService.sync();
-        }
-        else {
-            console.log("Git Worktree Sync script started as a scheduled job.");
-            console.log(`Job is scheduled with cron pattern: "${config.cronSchedule}"`);
-            console.log(`To see options, run: node ${path.basename(process.argv[1])} --help`);
-            console.log("Running initial sync...");
-            await syncService.sync();
-            console.log("Waiting for the next scheduled run...");
-            cron.schedule(config.cronSchedule, async () => {
-                try {
-                    await syncService.sync();
-                }
-                catch (error) {
-                    console.error("Error during scheduled sync:", error);
-                }
-            });
+      return await fn();
+    } catch (error) {
+      lfsContext.isLfsError = false;
+      if (!opts.shouldRetry(error, lfsContext)) {
+        throw error;
+      }
+      if (lfsContext.isLfsError) {
+        lfsAttempt++;
+        if (lfsAttempt > opts.maxLfsRetries) {
+          const err = error;
+          throw new Error(
+            `LFS error retry limit exceeded (${opts.maxLfsRetries} attempts). Consider using --skip-lfs option to bypass LFS downloads.`,
+            { cause: err }
+          );
         }
+      }
+      const isLastAttempt = opts.maxAttempts !== "unlimited" && attempt >= opts.maxAttempts;
+      if (isLastAttempt) {
+        throw error;
+      }
+      if (lfsContext.isLfsError && opts.lfsRetryHandler) {
+        opts.lfsRetryHandler(lfsContext);
+      }
+      const baseDelay = Math.min(opts.initialDelayMs * Math.pow(opts.backoffMultiplier, attempt - 1), opts.maxDelayMs);
+      const jitter = opts.jitterMs > 0 ? Math.random() * opts.jitterMs : 0;
+      const delay = baseDelay + jitter;
+      opts.onRetry(error, attempt, lfsContext);
+      await new Promise((resolve6) => setTimeout(resolve6, delay));
+      attempt++;
     }
-    catch (error) {
-        console.error("❌ Fatal Error during initialization:", error.message);
-        process.exit(1);
+  }
+}
+
+// src/utils/timing.ts
+import Table from "cli-table3";
+var Timer = class {
+  startTime;
+  endTime;
+  constructor() {
+    this.startTime = Date.now();
+  }
+  stop() {
+    this.endTime = Date.now();
+    return this.getDuration();
+  }
+  getDuration() {
+    const end = this.endTime ?? Date.now();
+    return end - this.startTime;
+  }
+};
+var PhaseTimer = class {
+  phases = /* @__PURE__ */ new Map();
+  currentPhase;
+  startPhase(name, parallelism) {
+    if (this.currentPhase) {
+      this.endPhase();
+    }
+    this.currentPhase = name;
+    this.phases.set(name, { timer: new Timer(), parallelism });
+  }
+  endPhase() {
+    if (this.currentPhase) {
+      const phase = this.phases.get(this.currentPhase);
+      if (phase) {
+        phase.timer.stop();
+      }
+      this.currentPhase = void 0;
     }
+  }
+  setPhaseCount(name, count) {
+    const phase = this.phases.get(name);
+    if (phase) {
+      phase.count = count;
+    }
+  }
+  getResults() {
+    if (this.currentPhase) {
+      this.endPhase();
+    }
+    const results = [];
+    for (const [name, { timer, count, parallelism }] of this.phases.entries()) {
+      const duration = timer.getDuration();
+      const result = {
+        name,
+        duration,
+        count
+      };
+      if (count && count > 0 && parallelism && parallelism > 1) {
+        const batches = Math.ceil(count / parallelism);
+        const avgTimePerBatch = duration / batches;
+        const theoreticalSequentialTime = count * avgTimePerBatch;
+        result.efficiency = theoreticalSequentialTime > 0 ? Math.round(theoreticalSequentialTime / duration * 100) : 100;
+      }
+      results.push(result);
+    }
+    return results;
+  }
+};
+function formatDuration2(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.floor(ms % 6e4 / 1e3);
+  return `${minutes}m ${seconds}s`;
 }
-async function runMultipleRepositories(repositories, runOnce) {
-    const services = new Map();
-    console.log(`\n🔄 Syncing ${repositories.length} repositories...`);
-    for (const repoConfig of repositories) {
-        console.log(`\n📦 Repository: ${repoConfig.name}`);
-        console.log(`   URL: ${repoConfig.repoUrl}`);
-        console.log(`   Worktrees: ${repoConfig.worktreeDir}`);
-        if (repoConfig.bareRepoDir) {
-            console.log(`   Bare repo: ${repoConfig.bareRepoDir}`);
-        }
-        const syncService = new worktree_sync_service_1.WorktreeSyncService(repoConfig);
-        services.set(repoConfig.name, syncService);
-        try {
-            await syncService.initialize();
-            await syncService.sync();
-        }
-        catch (error) {
-            console.error(`❌ Error syncing repository '${repoConfig.name}':`, error.message);
-        }
-    }
-    if (!runOnce) {
-        console.log("\n⏰ Scheduling cron jobs for all repositories...");
-        const cronJobs = new Map();
-        for (const repoConfig of repositories) {
-            const syncService = services.get(repoConfig.name);
-            if (!syncService)
-                continue;
-            if (!cronJobs.has(repoConfig.cronSchedule)) {
-                cronJobs.set(repoConfig.cronSchedule, repoConfig.cronSchedule);
-                cron.schedule(repoConfig.cronSchedule, async () => {
-                    const reposToSync = repositories.filter((r) => r.cronSchedule === repoConfig.cronSchedule);
-                    for (const repo of reposToSync) {
-                        const service = services.get(repo.name);
-                        if (!service)
-                            continue;
-                        console.log(`\n🔄 Running scheduled sync for: ${repo.name}`);
-                        try {
-                            await service.sync();
-                        }
-                        catch (error) {
-                            console.error(`Error during scheduled sync for '${repo.name}':`, error);
-                        }
-                    }
-                });
-            }
+function formatTimingTable(totalDuration, phaseResults, repoName) {
+  const header = repoName ? `Performance Summary - [${repoName}]` : "Performance Summary";
+  const table = new Table({
+    head: ["Operation", "Duration", "Efficiency"],
+    colWidths: [35, 12, 12],
+    style: {
+      head: ["cyan", "bold"],
+      border: ["gray"]
+    }
+  });
+  table.push([{ colSpan: 3, content: header, hAlign: "center" }]);
+  table.push(["Total Sync", formatDuration2(totalDuration), ""]);
+  for (let i = 0; i < phaseResults.length; i++) {
+    const result = phaseResults[i];
+    const isLast = i === phaseResults.length - 1;
+    const countStr = result.count ? ` (${result.count})` : "";
+    const prefix = isLast ? "\u2514\u2500" : "\u251C\u2500";
+    const name = `  ${prefix} ${result.name}${countStr}`;
+    const efficiency = result.efficiency ? `${result.efficiency}%` : "";
+    table.push([name, formatDuration2(result.duration), efficiency]);
+  }
+  return table.toString();
+}
+
+// src/services/git.service.ts
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+import simpleGit3 from "simple-git";
+
+// src/utils/git-url.ts
+function extractRepoNameFromUrl(gitUrl) {
+  const url = gitUrl.trim();
+  const sshMatch = url.match(/^git@[^:]+:(?:.+\/)?([^/]+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return sshMatch[1];
+  }
+  const sshUrlMatch = url.match(/^ssh:\/\/[^/]+\/(?:.+\/)?([^/]+?)(?:\.git)?$/);
+  if (sshUrlMatch) {
+    return sshUrlMatch[1];
+  }
+  const httpsMatch = url.match(/^https?:\/\/[^/]+\/(?:.+\/)?([^/]+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    return httpsMatch[1];
+  }
+  const fileMatch = url.match(/^file:\/\/(?:.+\/)?([^/]+?)(?:\.git)?$/);
+  if (fileMatch) {
+    return fileMatch[1];
+  }
+  throw new Error(`Invalid Git URL format: ${gitUrl}`);
+}
+function getDefaultBareRepoDir(repoUrl, baseDir = ".bare") {
+  const repoName = extractRepoNameFromUrl(repoUrl);
+  return `${baseDir}/${repoName}`;
+}
+
+// src/services/logger.service.ts
+var Logger = class _Logger {
+  repoName;
+  debugEnabled;
+  constructor(options = {}) {
+    this.repoName = options.repoName;
+    this.debugEnabled = options.debug ?? false;
+  }
+  prefix() {
+    return this.repoName ? `[${this.repoName}] ` : "";
+  }
+  debug(message, ...args) {
+    if (!this.debugEnabled) return;
+    console.log(this.prefix() + this.formatMessage(message, args));
+  }
+  info(message, ...args) {
+    console.log(this.prefix() + this.formatMessage(message, args));
+  }
+  warn(message, ...args) {
+    console.warn(this.prefix() + this.formatMessage(message, args));
+  }
+  error(message, error) {
+    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");
+  }
+  formatMessage(message, args) {
+    if (args.length === 0) {
+      return message;
+    }
+    return args.reduce((msg, arg) => msg.replace("%s", String(arg)), message);
+  }
+  static createDefault(repoName, debug) {
+    return new _Logger({ repoName, debug });
+  }
+};
+
+// src/services/worktree-metadata.service.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import simpleGit from "simple-git";
+var WorktreeMetadataService = class {
+  /**
+   * Gets the internal worktree directory name from a worktree path.
+   * Git uses the basename of the worktree path as the internal directory name.
+   * For example: /worktrees/fix/test-branch -> test-branch (not fix/test-branch)
+   */
+  getWorktreeDirectoryName(worktreePath) {
+    return path2.basename(worktreePath);
+  }
+  async getMetadataPath(bareRepoPath, worktreeName) {
+    return path2.join(
+      bareRepoPath,
+      METADATA_CONSTANTS.WORKTREE_METADATA_PATH,
+      worktreeName,
+      METADATA_CONSTANTS.METADATA_FILENAME
+    );
+  }
+  async getMetadataPathFromWorktreePath(bareRepoPath, worktreePath) {
+    const worktreeDirName = this.getWorktreeDirectoryName(worktreePath);
+    return this.getMetadataPath(bareRepoPath, worktreeDirName);
+  }
+  async saveMetadata(bareRepoPath, worktreeName, metadata) {
+    const metadataPath = await this.getMetadataPath(bareRepoPath, worktreeName);
+    await fs2.mkdir(path2.dirname(metadataPath), { recursive: true });
+    await fs2.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+  }
+  async loadMetadata(bareRepoPath, worktreeName) {
+    const metadataPath = await this.getMetadataPath(bareRepoPath, worktreeName);
+    try {
+      const content = await fs2.readFile(metadataPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async loadMetadataFromPath(bareRepoPath, worktreePath) {
+    const metadataPath = await this.getMetadataPathFromWorktreePath(bareRepoPath, worktreePath);
+    try {
+      const content = await fs2.readFile(metadataPath, "utf-8");
+      const metadata = JSON.parse(content);
+      if (!await this.validateMetadata(metadata)) {
+        console.warn(`Corrupted metadata for ${worktreePath}, treating as missing`);
+        return null;
+      }
+      return metadata;
+    } catch {
+      try {
+        const branchName = path2.basename(worktreePath);
+        const parentDir = path2.dirname(worktreePath);
+        const possibleBranchWithSlash = path2.join(path2.basename(parentDir), branchName);
+        const oldPath = path2.join(
+          bareRepoPath,
+          METADATA_CONSTANTS.WORKTREE_METADATA_PATH,
+          possibleBranchWithSlash,
+          METADATA_CONSTANTS.METADATA_FILENAME
+        );
+        const content = await fs2.readFile(oldPath, "utf-8");
+        const metadata = JSON.parse(content);
+        if (!await this.validateMetadata(metadata)) {
+          console.warn(`Corrupted metadata at old path ${oldPath}, treating as missing`);
+          return null;
         }
-        console.log("\n✅ All repositories scheduled. Waiting for next runs...");
-        for (const [schedule] of cronJobs) {
-            const repoCount = repositories.filter((r) => r.cronSchedule === schedule).length;
-            console.log(`   ${schedule}: ${repoCount} repository(ies)`);
+        await this.saveMetadata(bareRepoPath, this.getWorktreeDirectoryName(worktreePath), metadata);
+        try {
+          await fs2.unlink(oldPath);
+          await fs2.rm(path2.dirname(oldPath), { recursive: false, force: true });
+        } catch {
         }
+        return metadata;
+      } catch {
+        return null;
+      }
     }
-}
-async function listRepositories(configPath) {
-    const configLoader = new config_loader_service_1.ConfigLoaderService();
+  }
+  async deleteMetadata(bareRepoPath, worktreeName) {
+    const metadataPath = await this.getMetadataPath(bareRepoPath, worktreeName);
+    try {
+      await fs2.unlink(metadataPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  async deleteMetadataFromPath(bareRepoPath, worktreePath) {
+    const metadataPath = await this.getMetadataPathFromWorktreePath(bareRepoPath, worktreePath);
     try {
-        const configFile = await configLoader.loadConfigFile(configPath);
-        const configDir = path.dirname(path.resolve(configPath));
-        console.log("\n📋 Configured repositories:\n");
-        configFile.repositories.forEach((repo, index) => {
-            const resolved = configLoader.resolveRepositoryConfig(repo, configFile.defaults, configDir);
-            console.log(`${index + 1}. ${resolved.name}`);
-            console.log(`   URL: ${resolved.repoUrl}`);
-            console.log(`   Worktrees: ${resolved.worktreeDir}`);
-            console.log(`   Schedule: ${resolved.cronSchedule}`);
-            console.log(`   Run Once: ${resolved.runOnce}`);
-            if (resolved.bareRepoDir) {
-                console.log(`   Bare repo: ${resolved.bareRepoDir}`);
+      await fs2.unlink(metadataPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  async updateLastSync(bareRepoPath, worktreeName, commit, action = "updated") {
+    const existing = await this.loadMetadata(bareRepoPath, worktreeName);
+    if (!existing) {
+      console.warn(`No metadata found for worktree ${worktreeName}, skipping update`);
+      return;
+    }
+    existing.lastSyncCommit = commit;
+    existing.lastSyncDate = (/* @__PURE__ */ new Date()).toISOString();
+    existing.syncHistory.push({
+      date: existing.lastSyncDate,
+      commit,
+      action
+    });
+    if (existing.syncHistory.length > METADATA_CONSTANTS.MAX_HISTORY_ENTRIES) {
+      existing.syncHistory = existing.syncHistory.slice(-METADATA_CONSTANTS.MAX_HISTORY_ENTRIES);
+    }
+    await this.saveMetadata(bareRepoPath, worktreeName, existing);
+  }
+  async updateLastSyncFromPath(bareRepoPath, worktreePath, commit, action = "updated", defaultBranch) {
+    const worktreeDirName = this.getWorktreeDirectoryName(worktreePath);
+    const existing = await this.loadMetadataFromPath(bareRepoPath, worktreePath);
+    if (!existing) {
+      console.warn(`No metadata found for worktree ${worktreeDirName}`);
+      console.log(`  Attempting to create initial metadata...`);
+      try {
+        const worktreeGit = simpleGit(worktreePath);
+        const currentCommit = await worktreeGit.revparse(["HEAD"]);
+        const branchSummary = await worktreeGit.branch();
+        const actualBranchName = branchSummary.current;
+        if (!actualBranchName) {
+          throw new Error("Could not determine current branch name");
+        }
+        let upstreamBranch = `origin/${actualBranchName}`;
+        try {
+          const configuredUpstream = await worktreeGit.raw([
+            "rev-parse",
+            "--abbrev-ref",
+            `${actualBranchName}@{upstream}`
+          ]);
+          if (configuredUpstream.trim()) {
+            upstreamBranch = configuredUpstream.trim();
+          }
+        } catch {
+        }
+        const parentBranch = defaultBranch || GIT_CONSTANTS.DEFAULT_BRANCH;
+        await this.createInitialMetadataFromPath(
+          bareRepoPath,
+          worktreePath,
+          currentCommit.trim(),
+          upstreamBranch,
+          parentBranch,
+          currentCommit.trim()
+        );
+        console.log(`  \u2705 Created metadata for ${worktreeDirName}`);
+        return;
+      } catch (error) {
+        console.error(`  \u274C Failed to create metadata: ${error}`);
+        throw error;
+      }
+    }
+    existing.lastSyncCommit = commit;
+    existing.lastSyncDate = (/* @__PURE__ */ new Date()).toISOString();
+    existing.syncHistory.push({
+      date: existing.lastSyncDate,
+      commit,
+      action
+    });
+    if (existing.syncHistory.length > METADATA_CONSTANTS.MAX_HISTORY_ENTRIES) {
+      existing.syncHistory = existing.syncHistory.slice(-METADATA_CONSTANTS.MAX_HISTORY_ENTRIES);
+    }
+    await this.saveMetadata(bareRepoPath, worktreeDirName, existing);
+  }
+  async createInitialMetadata(bareRepoPath, worktreeName, commit, upstreamBranch, parentBranch, parentCommit) {
+    const metadata = {
+      lastSyncCommit: commit,
+      lastSyncDate: (/* @__PURE__ */ new Date()).toISOString(),
+      upstreamBranch,
+      createdFrom: {
+        branch: parentBranch,
+        commit: parentCommit
+      },
+      syncHistory: [
+        {
+          date: (/* @__PURE__ */ new Date()).toISOString(),
+          commit,
+          action: "created"
+        }
+      ]
+    };
+    await this.saveMetadata(bareRepoPath, worktreeName, metadata);
+  }
+  async createInitialMetadataFromPath(bareRepoPath, worktreePath, commit, upstreamBranch, parentBranch, parentCommit) {
+    const worktreeDirName = this.getWorktreeDirectoryName(worktreePath);
+    const metadata = {
+      lastSyncCommit: commit,
+      lastSyncDate: (/* @__PURE__ */ new Date()).toISOString(),
+      upstreamBranch,
+      createdFrom: {
+        branch: parentBranch,
+        commit: parentCommit
+      },
+      syncHistory: [
+        {
+          date: (/* @__PURE__ */ new Date()).toISOString(),
+          commit,
+          action: "created"
+        }
+      ]
+    };
+    await this.saveMetadata(bareRepoPath, worktreeDirName, metadata);
+  }
+  async validateMetadata(metadata) {
+    if (!metadata.lastSyncCommit || !metadata.lastSyncDate || !metadata.upstreamBranch) {
+      return false;
+    }
+    if (!/^[0-9a-f]+$/i.test(metadata.lastSyncCommit)) {
+      return false;
+    }
+    if (Number.isNaN(new Date(metadata.lastSyncDate).getTime())) {
+      return false;
+    }
+    return true;
+  }
+};
+
+// src/services/worktree-status.service.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+import simpleGit2 from "simple-git";
+
+// src/errors/index.ts
+var SyncWorktreesError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (cause && cause.stack) {
+      this.stack = `${this.stack}
+Caused by: ${cause.stack}`;
+    }
+  }
+};
+var GitError = class extends SyncWorktreesError {
+  constructor(message, code, cause) {
+    super(message, `GIT_${code}`, cause);
+  }
+};
+var GitOperationError = class extends GitError {
+  constructor(operation, details, cause) {
+    super(`Git operation '${operation}' failed: ${details}`, "OPERATION_FAILED", cause);
+  }
+};
+var WorktreeError = class extends SyncWorktreesError {
+  constructor(message, code, cause) {
+    super(message, `WORKTREE_${code}`, cause);
+  }
+};
+var WorktreeNotCleanError = class extends WorktreeError {
+  constructor(path9, reasons) {
+    super(`Worktree at '${path9}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
+    this.path = path9;
+    this.reasons = reasons;
+  }
+};
+
+// src/services/worktree-status.service.ts
+var WorktreeStatusService = class {
+  constructor(config = {}) {
+    this.config = config;
+  }
+  async checkWorktreeStatus(worktreePath) {
+    const worktreeGit = this.createGitInstance(worktreePath);
+    const status = await worktreeGit.status();
+    const hasTrackedChanges = status.modified.length > 0 || status.deleted.length > 0 || status.renamed.length > 0 || status.created.length > 0 || status.conflicted.length > 0;
+    if (hasTrackedChanges) {
+      return false;
+    }
+    if (status.not_added.length > 0) {
+      const untrackedFiles = status.not_added;
+      const notIgnoredFiles = await this.filterUntrackedFiles(worktreePath, untrackedFiles);
+      return notIgnoredFiles.length === 0;
+    }
+    return true;
+  }
+  async getFullWorktreeStatus(worktreePath, includeDetails = false, lastSyncCommit) {
+    const isClean = await this.checkWorktreeStatus(worktreePath);
+    const hasUnpushedCommits = await this.hasUnpushedCommits(worktreePath, lastSyncCommit);
+    const hasStashedChanges = await this.hasStashedChanges(worktreePath);
+    const hasOperationInProgress = await this.hasOperationInProgress(worktreePath);
+    const hasModifiedSubmodules = await this.hasModifiedSubmodules(worktreePath);
+    const upstreamGone = await this.hasUpstreamGone(worktreePath);
+    const reasons = [];
+    if (!isClean) reasons.push("uncommitted changes");
+    if (hasUnpushedCommits) reasons.push("unpushed commits");
+    if (hasStashedChanges) reasons.push("stashed changes");
+    if (hasOperationInProgress) reasons.push("operation in progress");
+    if (hasModifiedSubmodules) reasons.push("modified submodules");
+    const canRemove = isClean && !hasUnpushedCommits && !hasStashedChanges && !hasOperationInProgress && !hasModifiedSubmodules;
+    let details;
+    if (includeDetails) {
+      details = await this.getStatusDetails(worktreePath);
+    }
+    return {
+      isClean,
+      hasUnpushedCommits,
+      hasStashedChanges,
+      hasOperationInProgress,
+      hasModifiedSubmodules,
+      upstreamGone,
+      canRemove,
+      reasons,
+      details
+    };
+  }
+  async hasUnpushedCommits(worktreePath, lastSyncCommit) {
+    const worktreeGit = this.createGitInstance(worktreePath);
+    try {
+      if (await this.isDetachedHead(worktreeGit)) {
+        return false;
+      }
+      const branchSummary = await worktreeGit.branch();
+      const currentBranch = branchSummary.current;
+      if (lastSyncCommit) {
+        try {
+          const newCommitsResult = await worktreeGit.raw(["rev-list", "--count", `${lastSyncCommit}..HEAD`]);
+          const newCommitsCount = parseInt(newCommitsResult.trim(), 10);
+          return newCommitsCount > 0;
+        } catch {
+        }
+      }
+      const result = await worktreeGit.raw(["rev-list", "--count", currentBranch, "--not", "--remotes"]);
+      const unpushedCount = parseInt(result.trim(), 10);
+      return unpushedCount > 0;
+    } catch (error) {
+      console.error(`Error checking unpushed commits: ${error}`);
+      return false;
+    }
+  }
+  async hasUpstreamGone(worktreePath) {
+    const worktreeGit = this.createGitInstance(worktreePath);
+    try {
+      if (await this.isDetachedHead(worktreeGit)) {
+        return false;
+      }
+      const branchSummary = await worktreeGit.branch();
+      const currentBranch = branchSummary.current;
+      const upstream = await worktreeGit.raw(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`]);
+      const remoteBranches = await worktreeGit.branch(["-r"]);
+      return !remoteBranches.all.includes(upstream.trim());
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      if (errorMessage.includes("fatal: no upstream configured") || errorMessage.includes("no upstream configured for branch") || errorMessage.includes("fatal: ambiguous argument") || errorMessage.includes("unknown revision or path")) {
+        return false;
+      }
+      console.error(`Unexpected error checking upstream status for ${worktreePath}: ${errorMessage}`);
+      return false;
+    }
+  }
+  async hasStashedChanges(worktreePath) {
+    const worktreeGit = this.createGitInstance(worktreePath);
+    try {
+      const stashList = await worktreeGit.stashList();
+      return stashList.total > 0;
+    } catch (error) {
+      console.error(`Error checking stash: ${error}`);
+      return true;
+    }
+  }
+  async hasModifiedSubmodules(worktreePath) {
+    const worktreeGit = this.createGitInstance(worktreePath);
+    try {
+      const result = await worktreeGit.raw(["submodule", "status"]);
+      const lines = result.split("\n").filter((line) => line.trim());
+      for (const line of lines) {
+        const firstChar = line.charAt(0);
+        if (firstChar === GIT_CONSTANTS.SUBMODULE_STATUS_ADDED || firstChar === GIT_CONSTANTS.SUBMODULE_STATUS_REMOVED) {
+          return true;
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  async hasOperationInProgress(worktreePath) {
+    try {
+      const gitDir = await this.resolveGitDir(worktreePath);
+      const operationFiles = [
+        GIT_OPERATIONS.MERGE_HEAD,
+        GIT_OPERATIONS.CHERRY_PICK_HEAD,
+        GIT_OPERATIONS.REVERT_HEAD,
+        GIT_OPERATIONS.BISECT_LOG,
+        GIT_OPERATIONS.REBASE_MERGE,
+        GIT_OPERATIONS.REBASE_APPLY
+      ];
+      for (const file of operationFiles) {
+        try {
+          await fs3.access(path3.join(gitDir, file));
+          return true;
+        } catch {
+          continue;
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  async validateWorktreeForRemoval(worktreePath, lastSyncCommit) {
+    const status = await this.getFullWorktreeStatus(worktreePath, false, lastSyncCommit);
+    if (!status.canRemove) {
+      throw new WorktreeNotCleanError(worktreePath, status.reasons);
+    }
+  }
+  async getStatusDetails(worktreePath) {
+    const worktreeGit = this.createGitInstance(worktreePath);
+    const status = await worktreeGit.status();
+    const details = {
+      modifiedFiles: status.modified.length,
+      deletedFiles: status.deleted.length,
+      renamedFiles: status.renamed.length,
+      createdFiles: status.created.length,
+      conflictedFiles: status.conflicted.length,
+      untrackedFiles: 0
+    };
+    if (status.modified.length > 0) {
+      details.modifiedFilesList = status.modified;
+    }
+    if (status.deleted.length > 0) {
+      details.deletedFilesList = status.deleted;
+    }
+    if (status.renamed.length > 0) {
+      details.renamedFilesList = status.renamed.map((r) => ({ from: r.from, to: r.to }));
+    }
+    if (status.created.length > 0) {
+      details.createdFilesList = status.created;
+    }
+    if (status.conflicted.length > 0) {
+      details.conflictedFilesList = status.conflicted;
+    }
+    if (status.not_added.length > 0) {
+      const notIgnoredFiles = await this.filterUntrackedFiles(worktreePath, status.not_added);
+      details.untrackedFiles = notIgnoredFiles.length;
+      if (notIgnoredFiles.length > 0) {
+        details.untrackedFilesList = notIgnoredFiles;
+      }
+    }
+    try {
+      if (!await this.isDetachedHead(worktreeGit)) {
+        const branchSummary = await worktreeGit.branch();
+        const currentBranch = branchSummary.current;
+        const result = await worktreeGit.raw(["rev-list", "--count", currentBranch, "--not", "--remotes"]);
+        details.unpushedCommitCount = parseInt(result.trim(), 10);
+      }
+    } catch {
+      details.unpushedCommitCount = void 0;
+    }
+    try {
+      const stashList = await worktreeGit.stashList();
+      details.stashCount = stashList.total;
+    } catch {
+      details.stashCount = void 0;
+    }
+    const operationType = await this.getOperationType(worktreePath);
+    if (operationType) {
+      details.operationType = operationType;
+    }
+    try {
+      const result = await worktreeGit.raw(["submodule", "status"]);
+      const lines = result.split("\n").filter((line) => line.trim());
+      const modifiedSubmodules = [];
+      for (const line of lines) {
+        const firstChar = line.charAt(0);
+        if (firstChar === GIT_CONSTANTS.SUBMODULE_STATUS_ADDED || firstChar === GIT_CONSTANTS.SUBMODULE_STATUS_REMOVED) {
+          const match = line.match(/^[+-]\s*(\S+)/);
+          if (match) {
+            modifiedSubmodules.push(match[1]);
+          }
+        }
+      }
+      if (modifiedSubmodules.length > 0) {
+        details.modifiedSubmodules = modifiedSubmodules;
+      }
+    } catch {
+    }
+    return details;
+  }
+  async getOperationType(worktreePath) {
+    try {
+      const gitDir = await this.resolveGitDir(worktreePath);
+      const operations = [
+        { file: GIT_OPERATIONS.MERGE_HEAD, type: "merge" },
+        { file: GIT_OPERATIONS.CHERRY_PICK_HEAD, type: "cherry-pick" },
+        { file: GIT_OPERATIONS.REVERT_HEAD, type: "revert" },
+        { file: GIT_OPERATIONS.BISECT_LOG, type: "bisect" },
+        { file: GIT_OPERATIONS.REBASE_MERGE, type: "rebase" },
+        { file: GIT_OPERATIONS.REBASE_APPLY, type: "rebase (apply)" }
+      ];
+      for (const op of operations) {
+        try {
+          await fs3.access(path3.join(gitDir, op.file));
+          return op.type;
+        } catch {
+          continue;
+        }
+      }
+      return void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async filterUntrackedFiles(worktreePath, files) {
+    if (files.length === 0) return [];
+    const worktreeGit = this.createGitInstance(worktreePath);
+    try {
+      const result = await worktreeGit.raw(["check-ignore", "--", ...files]);
+      const ignoredFiles = new Set(
+        result.trim().split("\n").filter((f) => f)
+      );
+      return files.filter((f) => !ignoredFiles.has(f));
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      if (errorMessage.includes(GIT_CONSTANTS.GIT_CHECK_IGNORE_NO_MATCH)) {
+        return files;
+      }
+      console.warn(`Warning: Could not check gitignore status for files in ${worktreePath}: ${errorMessage}`);
+      return files;
+    }
+  }
+  async isDetachedHead(worktreeGit) {
+    try {
+      const branchSummary = await worktreeGit.branch();
+      return !branchSummary.current || branchSummary.detached;
+    } catch {
+      return true;
+    }
+  }
+  async resolveGitDir(worktreePath) {
+    const gitPath = path3.join(worktreePath, PATH_CONSTANTS.GIT_DIR);
+    try {
+      const stat4 = await fs3.stat(gitPath);
+      if (stat4.isFile()) {
+        const content = await fs3.readFile(gitPath, "utf-8");
+        const gitdirMatch = content.match(new RegExp(`^${GIT_CONSTANTS.GITDIR_PREFIX}\\s*(.+)$`, "m"));
+        if (gitdirMatch) {
+          return path3.resolve(worktreePath, gitdirMatch[1].trim());
+        }
+      }
+      return gitPath;
+    } catch (error) {
+      throw new GitOperationError(
+        "resolve-git-dir",
+        `Failed to resolve .git directory for ${worktreePath}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  createGitInstance(worktreePath) {
+    const git = simpleGit2(worktreePath);
+    return this.config.skipLfs ? git.env({ GIT_LFS_SKIP_SMUDGE: "1" }) : git;
+  }
+};
+
+// src/services/git.service.ts
+var GitService = class {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger ?? Logger.createDefault(void 0, config.debug);
+    this.bareRepoPath = this.config.bareRepoDir || getDefaultBareRepoDir(this.config.repoUrl);
+    this.mainWorktreePath = path4.join(this.config.worktreeDir, GIT_CONSTANTS.DEFAULT_BRANCH);
+    this.metadataService = new WorktreeMetadataService();
+    this.statusService = new WorktreeStatusService({ skipLfs: this.config.skipLfs });
+  }
+  git = null;
+  bareRepoPath;
+  mainWorktreePath;
+  defaultBranch = GIT_CONSTANTS.DEFAULT_BRANCH;
+  // Will be updated after detection
+  metadataService;
+  statusService;
+  logger;
+  async initialize() {
+    const { repoUrl } = this.config;
+    try {
+      await fs4.access(path4.join(this.bareRepoPath, "HEAD"));
+      this.logger.info(`Bare repository at "${this.bareRepoPath}" already exists. Using it.`);
+    } catch {
+      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();
+      await cloneGit.clone(repoUrl, this.bareRepoPath, ["--bare"]);
+      this.logger.info("\u2705 Clone successful.");
+    }
+    const bareGit = simpleGit3(this.bareRepoPath);
+    try {
+      const existingConfig = await bareGit.raw(["config", "--get-all", "remote.origin.fetch"]);
+      const targetConfig = "+refs/heads/*:refs/remotes/origin/*";
+      if (!existingConfig.includes(targetConfig)) {
+        await bareGit.addConfig("remote.origin.fetch", targetConfig);
+      }
+    } catch {
+      await bareGit.addConfig("remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*");
+    }
+    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);
+      needsMainWorktree = !worktrees.some((w) => path4.resolve(w.path) === path4.resolve(this.mainWorktreePath));
+    } catch {
+    }
+    if (needsMainWorktree) {
+      this.logger.info(`Creating ${this.defaultBranch} worktree at "${this.mainWorktreePath}"...`);
+      await fs4.mkdir(this.config.worktreeDir, { recursive: true });
+      const absoluteWorktreePath = path4.resolve(this.mainWorktreePath);
+      try {
+        const branches = await bareGit.branch();
+        const defaultBranchExists = branches.all.includes(this.defaultBranch);
+        if (defaultBranchExists) {
+          await bareGit.raw(["worktree", "add", absoluteWorktreePath, this.defaultBranch]);
+          const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(absoluteWorktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(absoluteWorktreePath);
+          await worktreeGit.branch(["--set-upstream-to", `origin/${this.defaultBranch}`, this.defaultBranch]);
+        } else {
+          await bareGit.raw([
+            "worktree",
+            "add",
+            "--track",
+            "-b",
+            this.defaultBranch,
+            absoluteWorktreePath,
+            `origin/${this.defaultBranch}`
+          ]);
+        }
+      } catch (error) {
+        const errorMessage = getErrorMessage(error);
+        if (errorMessage.includes("already exists")) {
+          this.logger.info(
+            `${this.defaultBranch} worktree directory already exists at '${absoluteWorktreePath}', skipping creation.`
+          );
+        } else {
+          this.logger.warn(`Failed to create ${this.defaultBranch} worktree with tracking, using simple add: ${error}`);
+          try {
+            await bareGit.raw(["worktree", "add", absoluteWorktreePath, this.defaultBranch]);
+          } catch (fallbackError) {
+            const fallbackErrorMessage = getErrorMessage(fallbackError);
+            if (fallbackErrorMessage.includes("already exists")) {
+              this.logger.info(
+                `${this.defaultBranch} worktree directory already exists at '${absoluteWorktreePath}', skipping creation.`
+              );
+            } else {
+              throw fallbackError;
             }
-            if (resolved.skipLfs) {
-                console.log(`   Skip LFS: ${resolved.skipLfs}`);
+          }
+        }
+      }
+      const updatedWorktrees = await this.getWorktreesFromBare(bareGit);
+      const mainWorktreeRegistered = updatedWorktrees.some(
+        (w) => path4.resolve(w.path) === path4.resolve(this.mainWorktreePath)
+      );
+      if (!mainWorktreeRegistered) {
+        if (process.env.NODE_ENV !== ENV_CONSTANTS.NODE_ENV_TEST) {
+          this.logger.warn(`Main worktree was created but not found in worktree list. This may cause issues.`);
+        }
+      }
+    }
+    this.git = simpleGit3(this.mainWorktreePath);
+    return this.git;
+  }
+  getGit() {
+    if (!this.git) {
+      throw new Error("Git service not initialized. Call initialize() first.");
+    }
+    return this.git;
+  }
+  getDefaultBranch() {
+    return this.defaultBranch;
+  }
+  async fetchAll() {
+    const git = this.getGit();
+    this.logger.info("Fetching latest data from remote...");
+    if (this.isLfsSkipEnabled()) {
+      await git.env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }).fetch(["--all", "--prune"]);
+    } else {
+      await git.fetch(["--all", "--prune"]);
+    }
+  }
+  async fetchBranch(branchName) {
+    const git = this.getGit();
+    if (this.isLfsSkipEnabled()) {
+      await git.env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }).fetch(["origin", branchName, "--prune"]);
+    } else {
+      await git.fetch(["origin", branchName, "--prune"]);
+    }
+  }
+  async getRemoteBranches() {
+    const git = this.getGit();
+    const branches = await git.branch(["-r"]);
+    return branches.all.filter((b) => b.startsWith("origin/") && !b.endsWith("/HEAD")).map((b) => b.replace("origin/", "")).filter((b) => b !== "origin" && b.length > 0);
+  }
+  async getRemoteBranchesWithActivity() {
+    const git = this.getGit();
+    const result = await git.raw([
+      "for-each-ref",
+      "--format=%(refname:short)|%(committerdate:iso8601)",
+      "refs/remotes/origin"
+    ]);
+    const branches = [];
+    const lines = result.trim().split("\n").filter((line) => line);
+    for (const line of lines) {
+      const [ref, dateStr] = line.split("|", 2);
+      if (ref && dateStr && !ref.endsWith("/HEAD")) {
+        const branch = ref.replace("origin/", "");
+        if (branch === "origin" || branch.length === 0) {
+          continue;
+        }
+        const lastActivity = new Date(dateStr);
+        if (!isNaN(lastActivity.getTime())) {
+          branches.push({ branch, lastActivity });
+        }
+      }
+    }
+    return branches;
+  }
+  async verifyLfsFilesDownloaded(worktreePath, branchName) {
+    const worktreeGit = simpleGit3(worktreePath);
+    try {
+      const lfsFiles = await worktreeGit.raw(["lfs", "ls-files", "--name-only"]);
+      const lfsFileList = lfsFiles.trim().split("\n").filter((f) => f.length > 0);
+      if (lfsFileList.length === 0) {
+        return;
+      }
+      if (this.config.debug) {
+        this.logger.info(`  - Verifying ${lfsFileList.length} LFS files are downloaded...`);
+      }
+      const sampleSize = Math.min(5, lfsFileList.length);
+      const samplesToCheck = [];
+      for (let i = 0; i < sampleSize; i++) {
+        const randomIndex = Math.floor(Math.random() * lfsFileList.length);
+        samplesToCheck.push(lfsFileList[randomIndex]);
+      }
+      let retries = 0;
+      const maxRetries = 30;
+      const retryDelay = 1e3;
+      while (retries < maxRetries) {
+        let allDownloaded = true;
+        const notDownloaded = [];
+        for (const file of samplesToCheck) {
+          const filePath = path4.join(worktreePath, file);
+          try {
+            const handle = await fs4.open(filePath, "r");
+            try {
+              const buffer = Buffer.alloc(200);
+              const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+              const header = buffer.subarray(0, bytesRead).toString("utf8");
+              if (header.startsWith(GIT_CONSTANTS.LFS_HEADER)) {
+                allDownloaded = false;
+                notDownloaded.push(file);
+              }
+            } finally {
+              await handle.close();
             }
-            console.log("");
-        });
+          } catch {
+            allDownloaded = false;
+            notDownloaded.push(file);
+          }
+        }
+        if (allDownloaded) {
+          if (this.config.debug) {
+            this.logger.info(`  - \u2705 LFS files verified (${samplesToCheck.length} samples checked)`);
+          }
+          return;
+        }
+        retries++;
+        if (retries < maxRetries) {
+          await new Promise((resolve6) => setTimeout(resolve6, retryDelay));
+        }
+      }
+      this.logger.warn(
+        `  - \u26A0\uFE0F Warning: Some LFS files may not be fully downloaded after ${maxRetries} seconds. This might cause issues if tools access the worktree immediately.`
+      );
+    } catch (error) {
+      this.logger.warn(`  - \u26A0\uFE0F Warning: Could not verify LFS files for '${branchName}': ${error}`);
     }
-    catch (error) {
-        console.error("❌ Error loading config file:", error.message);
-        process.exit(1);
+  }
+  async createWorktreeMetadata(bareGit, worktreePath, branchName) {
+    try {
+      const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(worktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(worktreePath);
+      const currentCommit = await worktreeGit.revparse(["HEAD"]);
+      const parentCommit = await bareGit.revparse([this.defaultBranch]);
+      await this.metadataService.createInitialMetadataFromPath(
+        this.bareRepoPath,
+        worktreePath,
+        currentCommit.trim(),
+        `origin/${branchName}`,
+        this.defaultBranch,
+        parentCommit.trim()
+      );
+    } catch (metadataError) {
+      this.logger.error(`  - \u274C Failed to create metadata for '${branchName}': ${metadataError}`);
+      throw new Error(`Metadata creation failed for ${branchName}. This worktree cannot be auto-managed.`);
     }
-}
-async function main() {
-    const options = (0, cli_1.parseArguments)();
-    if (options.config) {
-        const configLoader = new config_loader_service_1.ConfigLoaderService();
-        if (options.list) {
-            await listRepositories(options.config);
+  }
+  async addWorktree(branchName, worktreePath) {
+    const bareGit = this.isLfsSkipEnabled() ? simpleGit3(this.bareRepoPath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(this.bareRepoPath);
+    const absoluteWorktreePath = path4.resolve(worktreePath);
+    await fs4.mkdir(path4.dirname(absoluteWorktreePath), { recursive: true });
+    try {
+      await fs4.access(absoluteWorktreePath);
+      const worktrees = await this.getWorktreesFromBare(bareGit);
+      const isValidWorktree = worktrees.some((w) => path4.resolve(w.path) === absoluteWorktreePath);
+      if (isValidWorktree) {
+        this.logger.info(`  - Worktree for '${branchName}' already exists at '${absoluteWorktreePath}'`);
+        return;
+      } else {
+        this.logger.info(`  - Cleaning up orphaned directory at '${absoluteWorktreePath}'`);
+        await fs4.rm(absoluteWorktreePath, { recursive: true, force: true });
+      }
+    } catch {
+    }
+    try {
+      const branches = await bareGit.branch();
+      const localBranchExists = branches.all.includes(branchName);
+      if (localBranchExists || branchName.includes("/")) {
+        await bareGit.raw(["worktree", "add", absoluteWorktreePath, branchName]);
+        const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(absoluteWorktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(absoluteWorktreePath);
+        await worktreeGit.branch(["--set-upstream-to", `origin/${branchName}`, branchName]);
+      } else {
+        await bareGit.raw([
+          "worktree",
+          "add",
+          "--track",
+          "-b",
+          branchName,
+          absoluteWorktreePath,
+          `origin/${branchName}`
+        ]);
+      }
+      this.logger.info(`  - Created worktree for '${branchName}' with tracking to origin/${branchName}`);
+      if (!this.isLfsSkipEnabled()) {
+        await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
+      }
+      await this.createWorktreeMetadata(bareGit, absoluteWorktreePath, branchName);
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      if (errorMessage.includes("Metadata creation failed")) {
+        throw error;
+      }
+      if (errorMessage.includes("already registered worktree")) {
+        const worktrees = await this.getWorktreesFromBare(bareGit);
+        const existingWorktree = worktrees.find((w) => path4.resolve(w.path) === absoluteWorktreePath);
+        if (existingWorktree && !existingWorktree.isPrunable) {
+          this.logger.info(`  - Worktree for '${branchName}' was created by concurrent operation`);
+          return;
+        }
+        this.logger.warn(`  - Worktree already registered but missing. Pruning and retrying...`);
+        await bareGit.raw(["worktree", "prune"]);
+        try {
+          await fs4.rm(absoluteWorktreePath, { recursive: true, force: true });
+        } catch {
+        }
+        try {
+          await bareGit.raw([
+            "worktree",
+            "add",
+            "--track",
+            "-b",
+            branchName,
+            absoluteWorktreePath,
+            `origin/${branchName}`
+          ]);
+          this.logger.info(`  - Created worktree for '${branchName}' after pruning`);
+          if (!this.isLfsSkipEnabled()) {
+            await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
+          }
+          await this.createWorktreeMetadata(bareGit, absoluteWorktreePath, branchName);
+          return;
+        } catch (retryError) {
+          this.logger.error(`  - Failed to create worktree after pruning: ${retryError}`);
+          throw retryError;
+        }
+      }
+      this.logger.warn(`  - Failed to create worktree with tracking, falling back to simple add: ${error}`);
+      try {
+        await fs4.access(absoluteWorktreePath);
+        const worktrees = await this.getWorktreesFromBare(bareGit);
+        const isValidWorktree = worktrees.some((w) => path4.resolve(w.path) === absoluteWorktreePath);
+        if (isValidWorktree) {
+          this.logger.info(`  - Worktree for '${branchName}' already exists at '${absoluteWorktreePath}'`);
+          return;
+        } else {
+          this.logger.info(`  - Cleaning up orphaned directory at '${absoluteWorktreePath}' before fallback attempt`);
+          await fs4.rm(absoluteWorktreePath, { recursive: true, force: true });
+        }
+      } catch {
+      }
+      try {
+        await bareGit.raw(["worktree", "add", absoluteWorktreePath, branchName]);
+        this.logger.info(`  - Created worktree for '${branchName}' (without tracking)`);
+        if (!this.isLfsSkipEnabled()) {
+          await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
+        }
+        await this.createWorktreeMetadata(bareGit, absoluteWorktreePath, branchName);
+      } catch (fallbackError) {
+        const fallbackErrorMessage = getErrorMessage(fallbackError);
+        if (fallbackErrorMessage.includes("already registered worktree")) {
+          const worktrees = await this.getWorktreesFromBare(bareGit);
+          const existingWorktree = worktrees.find((w) => path4.resolve(w.path) === absoluteWorktreePath);
+          if (existingWorktree && !existingWorktree.isPrunable) {
+            this.logger.info(`  - Worktree for '${branchName}' was created by concurrent operation during fallback`);
             return;
+          }
         }
+        throw fallbackError;
+      }
+    }
+  }
+  async removeWorktree(worktreePath) {
+    const bareGit = simpleGit3(this.bareRepoPath);
+    await bareGit.raw(["worktree", "remove", worktreePath, "--force"]);
+    this.logger.info(`  - \u2705 Safely removed stale worktree at '${worktreePath}'.`);
+    try {
+      await this.metadataService.deleteMetadataFromPath(this.bareRepoPath, worktreePath);
+    } catch (metadataError) {
+      this.logger.warn(`Failed to delete metadata for worktree: ${metadataError}`);
+    }
+  }
+  async pruneWorktrees() {
+    const bareGit = simpleGit3(this.bareRepoPath);
+    await bareGit.raw(["worktree", "prune"]);
+    this.logger.info("Pruned worktree metadata.");
+  }
+  async checkWorktreeStatus(worktreePath) {
+    const worktreeGit = simpleGit3(worktreePath);
+    const status = await worktreeGit.status();
+    return status.isClean();
+  }
+  async isDetachedHead(worktreeGit) {
+    try {
+      const branchSummary = await worktreeGit.branch();
+      return !branchSummary.current || branchSummary.detached;
+    } catch {
+      return true;
+    }
+  }
+  async hasUnpushedCommits(worktreePath) {
+    const worktreeGit = simpleGit3(worktreePath);
+    try {
+      if (await this.isDetachedHead(worktreeGit)) {
+        return false;
+      }
+      const branchSummary = await worktreeGit.branch();
+      const currentBranch = branchSummary.current;
+      const upstreamGone = await this.hasUpstreamGone(worktreePath);
+      if (upstreamGone) {
+        const metadata = await this.metadataService.loadMetadataFromPath(this.bareRepoPath, worktreePath);
+        if (metadata?.lastSyncCommit) {
+          try {
+            const newCommitsResult = await worktreeGit.raw(["rev-list", "--count", `${metadata.lastSyncCommit}..HEAD`]);
+            const newCommitsCount = parseInt(newCommitsResult.trim(), 10);
+            return newCommitsCount > 0;
+          } catch {
+          }
+        }
+      }
+      const result = await worktreeGit.raw(["rev-list", "--count", currentBranch, "--not", "--remotes"]);
+      const unpushedCount = parseInt(result.trim(), 10);
+      return unpushedCount > 0;
+    } catch (error) {
+      this.logger.error(`Error checking unpushed commits: ${error}`);
+      return false;
+    }
+  }
+  async hasUpstreamGone(worktreePath) {
+    const worktreeGit = simpleGit3(worktreePath);
+    try {
+      if (await this.isDetachedHead(worktreeGit)) {
+        return false;
+      }
+      const branchSummary = await worktreeGit.branch();
+      const currentBranch = branchSummary.current;
+      const upstream = await worktreeGit.raw(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`]);
+      const remoteBranches = await worktreeGit.branch(["-r"]);
+      return !remoteBranches.all.includes(upstream.trim());
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      if (errorMessage.includes("fatal: no upstream configured") || errorMessage.includes("no upstream configured for branch")) {
+        return false;
+      }
+      if (errorMessage.includes("fatal: ambiguous argument") || errorMessage.includes("unknown revision or path")) {
         try {
-            const configFile = await configLoader.loadConfigFile(options.config);
-            const configDir = path.dirname(path.resolve(options.config));
-            let repositories = configFile.repositories.map((repo) => configLoader.resolveRepositoryConfig(repo, configFile.defaults, configDir, configFile.retry));
-            if (options.filter) {
-                repositories = configLoader.filterRepositories(repositories, options.filter);
-                if (repositories.length === 0) {
-                    console.error(`❌ No repositories match filter: ${options.filter}`);
-                    process.exit(1);
-                }
+          const branchSummary = await worktreeGit.branch();
+          const currentBranch = branchSummary.current;
+          const remoteResult = await worktreeGit.raw(["config", "--get", `branch.${currentBranch}.remote`]).catch(() => "");
+          const mergeResult = await worktreeGit.raw(["config", "--get", `branch.${currentBranch}.merge`]).catch(() => "");
+          const remote = remoteResult.trim();
+          const merge = mergeResult.trim();
+          if (remote && merge) {
+            const remoteBranchName = merge.replace("refs/heads/", "");
+            const expectedUpstream = `${remote}/${remoteBranchName}`;
+            const remoteBranches = await worktreeGit.branch(["-r"]);
+            return !remoteBranches.all.includes(expectedUpstream);
+          }
+        } catch {
+        }
+        return false;
+      }
+      this.logger.error(
+        `Unexpected error checking upstream status for ${worktreePath}. This might indicate a real issue rather than a missing upstream. Error: ${errorMessage}`
+      );
+      return false;
+    }
+  }
+  async hasStashedChanges(worktreePath) {
+    const worktreeGit = simpleGit3(worktreePath);
+    try {
+      const stashList = await worktreeGit.stashList();
+      return stashList.total > 0;
+    } catch (error) {
+      this.logger.error(`Error checking stash: ${error}`);
+      return true;
+    }
+  }
+  async getFullWorktreeStatus(worktreePath, includeDetails = false) {
+    const metadata = await this.metadataService.loadMetadataFromPath(this.bareRepoPath, worktreePath);
+    return this.statusService.getFullWorktreeStatus(worktreePath, includeDetails, metadata?.lastSyncCommit);
+  }
+  async hasModifiedSubmodules(worktreePath) {
+    const worktreeGit = simpleGit3(worktreePath);
+    try {
+      const result = await worktreeGit.raw(["submodule", "status"]);
+      return /^[+-]/m.test(result);
+    } catch {
+      return false;
+    }
+  }
+  async hasOperationInProgress(worktreePath) {
+    let resolvedGitDir = path4.join(worktreePath, ".git");
+    try {
+      const stat4 = await fs4.stat(resolvedGitDir);
+      if (stat4.isFile()) {
+        const content = await fs4.readFile(resolvedGitDir, "utf-8");
+        const match = content.match(/gitdir:\s*(.*)/i);
+        if (match && match[1]) {
+          resolvedGitDir = match[1].trim();
+          if (!path4.isAbsolute(resolvedGitDir)) {
+            resolvedGitDir = path4.resolve(worktreePath, resolvedGitDir);
+          }
+        }
+      }
+    } catch {
+    }
+    const checkFiles = ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "BISECT_LOG", "rebase-merge", "rebase-apply"];
+    for (const file of checkFiles) {
+      try {
+        await fs4.access(path4.join(resolvedGitDir, file));
+        return true;
+      } catch {
+      }
+    }
+    return false;
+  }
+  async getCurrentBranch() {
+    const git = this.getGit();
+    const branchSummary = await git.branch();
+    return branchSummary.current;
+  }
+  async detectDefaultBranch(bareGit) {
+    try {
+      const headRef = await bareGit.raw(["symbolic-ref", "refs/remotes/origin/HEAD"]);
+      const branch = headRef.trim().split("/").pop();
+      if (branch) {
+        return branch;
+      }
+    } catch {
+      try {
+        await bareGit.raw(["remote", "set-head", "origin", "-a"]);
+        const headRef = await bareGit.raw(["symbolic-ref", "refs/remotes/origin/HEAD"]);
+        const branch = headRef.trim().split("/").pop();
+        if (branch) {
+          return branch;
+        }
+      } catch {
+        try {
+          const remoteBranches = await bareGit.branch(["-r"]);
+          const commonDefaults = GIT_CONSTANTS.COMMON_DEFAULT_BRANCHES;
+          for (const defaultName of commonDefaults) {
+            if (remoteBranches.all.some((branch) => branch === `origin/${defaultName}`)) {
+              return defaultName;
             }
-            const globalRunOnce = options.runOnce ?? configFile.defaults?.runOnce ?? false;
-            // Apply CLI override for updateExistingWorktrees
-            if (options.noUpdateExisting) {
-                repositories = repositories.map((repo) => ({
-                    ...repo,
-                    updateExistingWorktrees: false,
-                }));
+          }
+        } catch {
+        }
+      }
+    }
+    return GIT_CONSTANTS.DEFAULT_BRANCH;
+  }
+  isLfsSkipEnabled() {
+    return this.config.skipLfs || process.env[ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE] === "1";
+  }
+  async getWorktrees() {
+    const bareGit = simpleGit3(this.bareRepoPath);
+    return this.getWorktreesFromBare(bareGit);
+  }
+  async isWorktreeBehind(worktreePath) {
+    const worktreeGit = simpleGit3(worktreePath);
+    try {
+      const branchSummary = await worktreeGit.branch();
+      const currentBranch = branchSummary.current;
+      const upstreamInfo = await worktreeGit.raw(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`]);
+      if (!upstreamInfo.trim()) {
+        return false;
+      }
+      const behindCount = await worktreeGit.raw(["rev-list", "--count", `HEAD..${upstreamInfo.trim()}`]);
+      return parseInt(behindCount.trim(), 10) > 0;
+    } catch {
+      return false;
+    }
+  }
+  async updateWorktree(worktreePath) {
+    const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(worktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(worktreePath);
+    const branchSummary = await worktreeGit.branch();
+    const currentBranch = branchSummary.current;
+    await worktreeGit.merge([`origin/${currentBranch}`, "--ff-only"]);
+    const isMainWorktree = path4.resolve(worktreePath) === path4.resolve(this.mainWorktreePath);
+    if (isMainWorktree) {
+      return;
+    }
+    try {
+      const currentCommit = await worktreeGit.revparse(["HEAD"]);
+      await this.metadataService.updateLastSyncFromPath(
+        this.bareRepoPath,
+        worktreePath,
+        currentCommit.trim(),
+        "updated",
+        this.defaultBranch
+      );
+    } catch (metadataError) {
+      this.logger.warn(`Failed to update metadata for worktree: ${metadataError}`);
+    }
+  }
+  async hasDivergedHistory(worktreePath, expectedBranch) {
+    const worktreeGit = simpleGit3(worktreePath);
+    const branchInfo = await worktreeGit.branch();
+    if (branchInfo.current !== expectedBranch) {
+      this.logger.warn(`Branch mismatch in hasDivergedHistory: expected ${expectedBranch}, got ${branchInfo.current}`);
+      return false;
+    }
+    try {
+      await worktreeGit.raw(["merge-base", "--is-ancestor", "HEAD", `origin/${expectedBranch}`]);
+      return false;
+    } catch {
+      return true;
+    }
+  }
+  async canFastForward(worktreePath, branch) {
+    const worktreeGit = simpleGit3(worktreePath);
+    try {
+      const mergeBase = await worktreeGit.raw(["merge-base", "HEAD", `origin/${branch}`]);
+      const mergeBaseSha = mergeBase.trim();
+      const headSha = await worktreeGit.revparse(["HEAD"]);
+      const headShaTrimmed = headSha.trim();
+      return mergeBaseSha === headShaTrimmed;
+    } catch {
+      return false;
+    }
+  }
+  async compareTreeContent(worktreePath, branch) {
+    const worktreeGit = simpleGit3(worktreePath);
+    try {
+      const localTree = await worktreeGit.raw(["rev-parse", "HEAD^{tree}"]);
+      const remoteTree = await worktreeGit.raw(["rev-parse", `origin/${branch}^{tree}`]);
+      return localTree.trim() === remoteTree.trim();
+    } catch (error) {
+      this.logger.error(`Error comparing tree content: ${error}`);
+      return false;
+    }
+  }
+  async resetToUpstream(worktreePath, branch) {
+    const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(worktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(worktreePath);
+    await worktreeGit.reset(["--hard", `origin/${branch}`]);
+    try {
+      const currentCommit = await worktreeGit.revparse(["HEAD"]);
+      await this.metadataService.updateLastSyncFromPath(
+        this.bareRepoPath,
+        worktreePath,
+        currentCommit.trim(),
+        "updated",
+        this.defaultBranch
+      );
+    } catch (metadataError) {
+      this.logger.warn(`Failed to update metadata after reset: ${metadataError}`);
+    }
+  }
+  async getCurrentCommit(worktreePath) {
+    const worktreeGit = simpleGit3(worktreePath);
+    const commit = await worktreeGit.revparse(["HEAD"]);
+    return commit.trim();
+  }
+  async getRemoteCommit(ref) {
+    const git = simpleGit3(this.bareRepoPath);
+    const commit = await git.revparse([ref]);
+    return commit.trim();
+  }
+  async getWorktreeMetadata(worktreePath) {
+    return this.metadataService.loadMetadataFromPath(this.bareRepoPath, worktreePath);
+  }
+  async getWorktreesFromBare(bareGit) {
+    const result = await bareGit.raw(["worktree", "list", "--porcelain"]);
+    const worktrees = [];
+    const lines = result.trim().split("\n");
+    let currentWorktree = {};
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        currentWorktree.path = line.substring(9);
+      } else if (line.startsWith("branch ")) {
+        currentWorktree.branch = line.substring(7).replace("refs/heads/", "");
+      } else if (line === "detached") {
+        currentWorktree.detached = true;
+      } else if (line === "prunable") {
+        currentWorktree.prunable = true;
+      } else if (line.trim() === "") {
+        if (currentWorktree.path) {
+          if (currentWorktree.branch && !currentWorktree.detached) {
+            worktrees.push({
+              path: currentWorktree.path,
+              branch: currentWorktree.branch,
+              isPrunable: currentWorktree.prunable || false
+            });
+          }
+        }
+        currentWorktree = {};
+      }
+    }
+    if (currentWorktree.path && currentWorktree.branch && !currentWorktree.detached) {
+      worktrees.push({
+        path: currentWorktree.path,
+        branch: currentWorktree.branch,
+        isPrunable: currentWorktree.prunable || false
+      });
+    }
+    return worktrees;
+  }
+};
+
+// src/services/worktree-sync.service.ts
+var WorktreeSyncService = class {
+  constructor(config) {
+    this.config = config;
+    this.logger = config.logger ?? Logger.createDefault(void 0, config.debug);
+    this.gitService = new GitService(config, this.logger);
+  }
+  gitService;
+  logger;
+  syncInProgress = false;
+  async initialize() {
+    await this.gitService.initialize();
+  }
+  isSyncInProgress() {
+    return this.syncInProgress;
+  }
+  async sync() {
+    if (this.syncInProgress) {
+      this.logger.warn("\u26A0\uFE0F  Sync already in progress, skipping...");
+      return;
+    }
+    this.syncInProgress = true;
+    this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Starting worktree synchronization...`);
+    const totalTimer = new Timer();
+    const phaseTimer = new PhaseTimer();
+    let lfsSkipEnabled = false;
+    const retryOptions = {
+      maxAttempts: this.config.retry?.maxAttempts ?? 3,
+      maxLfsRetries: this.config.retry?.maxLfsRetries ?? 2,
+      initialDelayMs: this.config.retry?.initialDelayMs ?? 1e3,
+      maxDelayMs: this.config.retry?.maxDelayMs ?? 3e4,
+      backoffMultiplier: this.config.retry?.backoffMultiplier ?? 2,
+      onRetry: (error, attempt, context) => {
+        const errorMessage = getErrorMessage(error);
+        this.logger.info(`
+\u26A0\uFE0F  Sync attempt ${attempt} failed: ${errorMessage}`);
+        if (context?.isLfsError && !this.config.skipLfs) {
+          this.logger.info(`\u{1F504} LFS error detected. Will retry with LFS skipped...`);
+        } else {
+          this.logger.info(`\u{1F504} Retrying synchronization...
+`);
+        }
+      },
+      lfsRetryHandler: () => {
+        if (!this.config.skipLfs && !lfsSkipEnabled) {
+          this.logger.info("\u26A0\uFE0F  Temporarily disabling LFS downloads for this sync...");
+          process.env.GIT_LFS_SKIP_SMUDGE = "1";
+          lfsSkipEnabled = true;
+        }
+      }
+    };
+    try {
+      await retry(async () => {
+        await this.gitService.pruneWorktrees();
+        this.logger.info("Step 1: Fetching latest data from remote...");
+        phaseTimer.startPhase("Phase 1: Fetch");
+        try {
+          await this.gitService.fetchAll();
+        } catch (fetchError) {
+          const errorMessage = getErrorMessage(fetchError);
+          if (isLfsError(errorMessage) && !lfsSkipEnabled && !this.config.skipLfs) {
+            this.logger.info("\u26A0\uFE0F  Fetch all failed due to LFS error. Attempting branch-by-branch fetch...");
+            this.logger.info("\u26A0\uFE0F  Temporarily disabling LFS downloads for branch-by-branch fetch...");
+            process.env.GIT_LFS_SKIP_SMUDGE = "1";
+            lfsSkipEnabled = true;
+            await this.fetchBranchByBranch();
+          } else {
+            throw fetchError;
+          }
+        }
+        phaseTimer.endPhase();
+        let remoteBranches;
+        if (this.config.branchMaxAge) {
+          const branchesWithActivity = await this.gitService.getRemoteBranchesWithActivity();
+          const filteredBranches = filterBranchesByAge(branchesWithActivity, this.config.branchMaxAge);
+          remoteBranches = filteredBranches.map((b) => b.branch);
+          this.logger.info(`Found ${branchesWithActivity.length} remote branches.`);
+          this.logger.info(
+            `After filtering by age (${formatDuration(this.config.branchMaxAge)}): ${remoteBranches.length} branches.`
+          );
+          if (branchesWithActivity.length > remoteBranches.length) {
+            const excludedCount = branchesWithActivity.length - remoteBranches.length;
+            this.logger.info(`  - Excluded ${excludedCount} stale branches.`);
+          }
+        } else {
+          remoteBranches = await this.gitService.getRemoteBranches();
+          this.logger.info(`Found ${remoteBranches.length} remote branches.`);
+        }
+        const defaultBranch = this.gitService.getDefaultBranch();
+        if (!remoteBranches.includes(defaultBranch)) {
+          remoteBranches.push(defaultBranch);
+          this.logger.info(`Ensuring default branch '${defaultBranch}' is retained.`);
+        }
+        await fs5.mkdir(this.config.worktreeDir, { recursive: true });
+        const worktrees = await this.gitService.getWorktrees();
+        const worktreeBranches = worktrees.map((w) => w.branch);
+        this.logger.info(`Found ${worktrees.length} existing Git worktrees.`);
+        await this.cleanupOrphanedDirectories(worktrees);
+        await this.createNewWorktreesWithTiming(remoteBranches, worktreeBranches, defaultBranch, phaseTimer);
+        await this.pruneOldWorktreesWithTiming(remoteBranches, worktreeBranches, phaseTimer);
+        if (this.config.updateExistingWorktrees !== false) {
+          await this.updateExistingWorktreesWithTiming(worktrees, remoteBranches, phaseTimer);
+        }
+        phaseTimer.startPhase("Phase 5: Cleanup");
+        await this.gitService.pruneWorktrees();
+        this.logger.info("Step 5: Pruned worktree metadata.");
+        phaseTimer.endPhase();
+      }, retryOptions);
+    } catch (error) {
+      this.logger.error("\n\u274C Error during worktree synchronization after all retry attempts:", error);
+      throw error;
+    } finally {
+      if (lfsSkipEnabled && !this.config.skipLfs) {
+        delete process.env.GIT_LFS_SKIP_SMUDGE;
+      }
+      this.syncInProgress = false;
+      this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Synchronization finished.
+`);
+      if (this.config.debug) {
+        const totalDuration = totalTimer.stop();
+        const phaseResults = phaseTimer.getResults();
+        const repoName = this.config.name;
+        this.logger.table(formatTimingTable(totalDuration, phaseResults, repoName));
+      }
+    }
+  }
+  async createNewWorktreesWithTiming(remoteBranches, existingWorktreeBranches, defaultBranch, phaseTimer) {
+    const maxConcurrent = this.config.parallelism?.maxWorktreeCreation ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_CREATION;
+    phaseTimer.startPhase("Phase 2: Create", maxConcurrent);
+    await this.createNewWorktrees(remoteBranches, existingWorktreeBranches, defaultBranch);
+    const newBranches = remoteBranches.filter((b) => !existingWorktreeBranches.includes(b)).filter((b) => b !== defaultBranch);
+    phaseTimer.setPhaseCount("Phase 2: Create", newBranches.length);
+    phaseTimer.endPhase();
+  }
+  async createNewWorktrees(remoteBranches, existingWorktreeBranches, defaultBranch) {
+    const newBranches = remoteBranches.filter((b) => !existingWorktreeBranches.includes(b)).filter((b) => b !== defaultBranch);
+    if (newBranches.length > 0) {
+      this.logger.info(`Step 2: Creating ${newBranches.length} new worktrees...`);
+      const maxConcurrent = this.config.parallelism?.maxWorktreeCreation ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_CREATION;
+      const limit = pLimit(maxConcurrent);
+      const results = await Promise.allSettled(
+        newBranches.map(
+          (branchName) => limit(async () => {
+            const worktreePath = path5.join(this.config.worktreeDir, branchName);
+            try {
+              await this.gitService.addWorktree(branchName, worktreePath);
+              this.logger.info(`  \u2705 Created worktree for '${branchName}'`);
+            } catch (error) {
+              this.logger.error(`  \u274C Failed to create worktree for '${branchName}':`, getErrorMessage(error));
+              throw error;
             }
-            await runMultipleRepositories(repositories, globalRunOnce);
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes("Config file not found")) {
-                console.error(`\n❌ Config file not found: ${options.config}`);
-                const createConfig = await (0, prompts_1.confirm)({
-                    message: "Would you like to run interactive setup to create a config file?",
-                    default: true,
-                });
-                if (createConfig) {
-                    // Run interactive mode which will offer to save config
-                    const config = await (0, interactive_1.promptForConfig)({});
-                    await runSingleRepository(config);
-                }
-                else {
-                    console.log("\n💡 You can create a config file manually or run without --config for interactive setup.");
-                    process.exit(1);
+          })
+        )
+      );
+      const successCount = results.filter((r) => r.status === "fulfilled").length;
+      this.logger.info(`  Created ${successCount}/${newBranches.length} worktrees successfully`);
+    } else {
+      this.logger.info("Step 2: No new branches to create worktrees for.");
+    }
+  }
+  async pruneOldWorktreesWithTiming(remoteBranches, existingWorktreeBranches, phaseTimer) {
+    const maxConcurrent = this.config.parallelism?.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS;
+    phaseTimer.startPhase("Phase 3: Prune", maxConcurrent);
+    await this.pruneOldWorktrees(remoteBranches, existingWorktreeBranches);
+    const deletedBranches = existingWorktreeBranches.filter((branch) => !remoteBranches.includes(branch));
+    phaseTimer.setPhaseCount("Phase 3: Prune", deletedBranches.length);
+    phaseTimer.endPhase();
+  }
+  async pruneOldWorktrees(remoteBranches, existingWorktreeBranches) {
+    const deletedBranches = existingWorktreeBranches.filter((branch) => !remoteBranches.includes(branch));
+    if (deletedBranches.length > 0) {
+      this.logger.info(`Step 3: Checking ${deletedBranches.length} stale worktrees to prune...`);
+      const maxConcurrent = this.config.parallelism?.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS;
+      const limit = pLimit(maxConcurrent);
+      const statusResults = await Promise.allSettled(
+        deletedBranches.map(
+          (branchName) => limit(async () => {
+            const worktreePath = path5.join(this.config.worktreeDir, branchName);
+            const status = await this.gitService.getFullWorktreeStatus(worktreePath, this.config.debug);
+            return { branchName, worktreePath, status };
+          })
+        )
+      );
+      const toRemove = [];
+      const toSkip = [];
+      for (const result of statusResults) {
+        if (result.status === "fulfilled") {
+          const { branchName, worktreePath, status } = result.value;
+          if (status.canRemove) {
+            toRemove.push({ branchName, worktreePath });
+          } else {
+            toSkip.push({ branchName, status });
+          }
+        } else {
+          this.logger.error(`  - Error checking worktree:`, result.reason);
+        }
+      }
+      if (toRemove.length > 0) {
+        const removeLimit = pLimit(
+          this.config.parallelism?.maxWorktreeRemoval ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_REMOVAL
+        );
+        const removeResults = await Promise.allSettled(
+          toRemove.map(
+            ({ branchName, worktreePath }) => removeLimit(async () => {
+              try {
+                await this.gitService.removeWorktree(worktreePath);
+                this.logger.info(`  \u2705 Removed worktree for '${branchName}'`);
+              } catch (error) {
+                this.logger.error(`  \u274C Failed to remove worktree for '${branchName}':`, getErrorMessage(error));
+                throw error;
+              }
+            })
+          )
+        );
+        const removedCount = removeResults.filter((r) => r.status === "fulfilled").length;
+        this.logger.info(`  Removed ${removedCount}/${toRemove.length} worktrees successfully`);
+      }
+      if (toSkip.length > 0) {
+        this.logger.info(`  Skipped ${toSkip.length} worktree(s) with local changes or unpushed commits`);
+      }
+      for (const { branchName, status } of toSkip) {
+        if (status.upstreamGone && status.hasUnpushedCommits) {
+          const worktreePath = path5.join(this.config.worktreeDir, branchName);
+          this.logger.warn(`  - \u26A0\uFE0F Cannot automatically remove '${branchName}' - upstream branch was deleted.`);
+          this.logger.info(`     Please review manually: cd ${worktreePath} && git log`);
+          this.logger.info(
+            `     If changes were squash-merged, you can safely remove with: git worktree remove ${worktreePath}`
+          );
+        } else {
+          this.logger.info(`  - \u26A0\uFE0F Skipping removal of '${branchName}' due to: ${status.reasons.join(", ")}.`);
+        }
+        if (this.config.debug && status.details) {
+          this.logDebugDetails(branchName, status.details);
+        }
+      }
+    } else {
+      this.logger.info("Step 3: No stale worktrees to prune.");
+    }
+  }
+  logDebugDetails(branchName, details) {
+    this.logger.info(`
+     \u{1F50D} Debug details for '${branchName}':`);
+    if (details.modifiedFiles > 0 && details.modifiedFilesList) {
+      this.logger.info(`        - Modified files (${details.modifiedFiles}):`);
+      details.modifiedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
+    }
+    if (details.deletedFiles > 0 && details.deletedFilesList) {
+      this.logger.info(`        - Deleted files (${details.deletedFiles}):`);
+      details.deletedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
+    }
+    if (details.renamedFiles > 0 && details.renamedFilesList) {
+      this.logger.info(`        - Renamed files (${details.renamedFiles}):`);
+      details.renamedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file.from} \u2192 ${file.to}`));
+    }
+    if (details.createdFiles > 0 && details.createdFilesList) {
+      this.logger.info(`        - Created files (${details.createdFiles}):`);
+      details.createdFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
+    }
+    if (details.conflictedFiles > 0 && details.conflictedFilesList) {
+      this.logger.info(`        - Conflicted files (${details.conflictedFiles}):`);
+      details.conflictedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
+    }
+    if (details.untrackedFiles > 0 && details.untrackedFilesList) {
+      this.logger.info(`        - Untracked files (not ignored) (${details.untrackedFiles}):`);
+      details.untrackedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
+    }
+    if (details.unpushedCommitCount !== void 0 && details.unpushedCommitCount > 0) {
+      this.logger.info(`        - Unpushed commits: ${details.unpushedCommitCount}`);
+    }
+    if (details.stashCount !== void 0 && details.stashCount > 0) {
+      this.logger.info(`        - Stashed changes: ${details.stashCount}`);
+    }
+    if (details.operationType) {
+      this.logger.info(`        - Operation in progress: ${details.operationType}`);
+    }
+    if (details.modifiedSubmodules && details.modifiedSubmodules.length > 0) {
+      this.logger.info(`        - Modified submodules (${details.modifiedSubmodules.length}):`);
+      details.modifiedSubmodules.forEach((submodule) => this.logger.info(`          \u2022 ${submodule}`));
+    }
+    this.logger.info("");
+  }
+  async fetchBranchByBranch() {
+    this.logger.info("Fetching branches individually to isolate LFS errors...");
+    const remoteBranches = await this.gitService.getRemoteBranches();
+    this.logger.info(`Found ${remoteBranches.length} remote branches to fetch.`);
+    const failedBranches = [];
+    let successCount = 0;
+    for (const branch of remoteBranches) {
+      try {
+        await this.gitService.fetchBranch(branch);
+        successCount++;
+      } catch (error) {
+        const errorMessage = getErrorMessage(error);
+        this.logger.info(`  \u26A0\uFE0F  Failed to fetch branch '${branch}': ${errorMessage}`);
+        failedBranches.push(branch);
+      }
+    }
+    this.logger.info(`Branch-by-branch fetch completed: ${successCount}/${remoteBranches.length} successful`);
+    if (failedBranches.length > 0) {
+      this.logger.info(`\u26A0\uFE0F  Failed to fetch ${failedBranches.length} branches due to errors.`);
+      this.logger.info(`   These branches will be skipped: ${failedBranches.join(", ")}`);
+    }
+  }
+  async updateExistingWorktreesWithTiming(worktrees, remoteBranches, phaseTimer) {
+    const maxConcurrent = this.config.parallelism?.maxWorktreeUpdates ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_UPDATES;
+    phaseTimer.startPhase("Phase 4: Update", maxConcurrent);
+    await this.updateExistingWorktrees(worktrees, remoteBranches);
+    const activeWorktrees = worktrees.filter((w) => remoteBranches.includes(w.branch));
+    phaseTimer.setPhaseCount("Phase 4: Update", activeWorktrees.length);
+    phaseTimer.endPhase();
+  }
+  async updateExistingWorktrees(worktrees, remoteBranches) {
+    this.logger.info("Step 4: Checking for worktrees that need updates...");
+    const divergedDir = path5.join(this.config.worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
+    try {
+      const diverged = await fs5.readdir(divergedDir);
+      if (diverged.length > 0) {
+        this.logger.info(
+          `\u{1F4E6} Note: ${diverged.length} diverged worktree(s) in ${path5.relative(process.cwd(), divergedDir)}`
+        );
+      }
+    } catch {
+    }
+    const activeWorktrees = worktrees.filter((w) => remoteBranches.includes(w.branch));
+    const maxConcurrent = this.config.parallelism?.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS;
+    const limit = pLimit(maxConcurrent);
+    const checkResults = await Promise.allSettled(
+      activeWorktrees.map(
+        (worktree) => limit(async () => {
+          try {
+            await fs5.access(worktree.path);
+          } catch {
+            return null;
+          }
+          const hasOp = await this.gitService.hasOperationInProgress(worktree.path);
+          if (hasOp) return null;
+          const isClean = await this.gitService.checkWorktreeStatus(worktree.path);
+          if (!isClean) return null;
+          const canFastForward = await this.gitService.canFastForward(worktree.path, worktree.branch);
+          if (!canFastForward) {
+            await this.handleDivergedBranch(worktree);
+            return null;
+          }
+          const isBehind = await this.gitService.isWorktreeBehind(worktree.path);
+          return isBehind ? worktree : null;
+        })
+      )
+    );
+    const worktreesToUpdate = [];
+    for (const result of checkResults) {
+      if (result.status === "fulfilled" && result.value) {
+        worktreesToUpdate.push(result.value);
+      } else if (result.status === "rejected") {
+        this.logger.error(`  - Error checking worktree:`, result.reason);
+      }
+    }
+    if (worktreesToUpdate.length > 0) {
+      this.logger.info(`  - Found ${worktreesToUpdate.length} worktrees behind their upstream branches.`);
+      const updateLimit = pLimit(
+        this.config.parallelism?.maxWorktreeUpdates ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_UPDATES
+      );
+      const updateResults = await Promise.allSettled(
+        worktreesToUpdate.map(
+          (worktree) => updateLimit(async () => {
+            try {
+              this.logger.info(`  - Updating worktree '${worktree.branch}'...`);
+              await this.gitService.updateWorktree(worktree.path);
+              this.logger.info(`    \u2705 Successfully updated '${worktree.branch}'.`);
+            } catch (error) {
+              const errorMessage = getErrorMessage(error);
+              if (ERROR_MESSAGES.FAST_FORWARD_FAILED.some((msg) => errorMessage.includes(msg))) {
+                this.logger.info(
+                  `    \u26A0\uFE0F Branch '${worktree.branch}' cannot be fast-forwarded. Checking for divergence...`
+                );
+                try {
+                  await this.handleDivergedBranch(worktree);
+                } catch (divergedError) {
+                  this.logger.error(`    \u274C Failed to handle diverged branch '${worktree.branch}':`, divergedError);
                 }
+              } else {
+                this.logger.error(`    \u274C Failed to update '${worktree.branch}':`, error);
+              }
+              throw error;
             }
-            else {
-                console.error("❌ Error loading config file:", error.message);
-                process.exit(1);
+          })
+        )
+      );
+      const successCount = updateResults.filter((r) => r.status === "fulfilled").length;
+      this.logger.info(`  Updated ${successCount}/${worktreesToUpdate.length} worktrees successfully`);
+    } else {
+      this.logger.info("  - All worktrees are up to date.");
+    }
+  }
+  async cleanupOrphanedDirectories(worktrees) {
+    try {
+      const worktreeRelativePaths = worktrees.map((w) => path5.relative(this.config.worktreeDir, w.path));
+      const allDirs = await fs5.readdir(this.config.worktreeDir);
+      const regularDirs = allDirs.filter((dir) => !dir.startsWith("."));
+      const orphanedDirs = [];
+      for (const dir of regularDirs) {
+        const isPartOfWorktree = worktreeRelativePaths.some((worktreePath) => {
+          return worktreePath === dir || worktreePath.startsWith(dir + path5.sep);
+        });
+        if (!isPartOfWorktree) {
+          orphanedDirs.push(dir);
+        }
+      }
+      if (orphanedDirs.length > 0) {
+        this.logger.info(`Found ${orphanedDirs.length} orphaned directories: ${orphanedDirs.join(", ")}`);
+        for (const dir of orphanedDirs) {
+          const dirPath = path5.join(this.config.worktreeDir, dir);
+          try {
+            const stat4 = await fs5.stat(dirPath);
+            if (stat4.isDirectory()) {
+              await fs5.rm(dirPath, { recursive: true, force: true });
+              this.logger.info(`  - Removed orphaned directory: ${dir}`);
             }
+          } catch (error) {
+            this.logger.error(`  - Failed to remove orphaned directory ${dir}:`, error);
+          }
         }
+      }
+    } catch (error) {
+      this.logger.error("Error during orphaned directory cleanup:", error);
+    }
+  }
+  async handleDivergedBranch(worktree) {
+    this.logger.info(`\u26A0\uFE0F  Branch '${worktree.branch}' has diverged from upstream. Analyzing...`);
+    const treesIdentical = await this.gitService.compareTreeContent(worktree.path, worktree.branch);
+    if (treesIdentical) {
+      this.logger.info(`\u2705 Branch '${worktree.branch}' was rebased but files are identical. Resetting to upstream...`);
+      await this.gitService.resetToUpstream(worktree.path, worktree.branch);
+      this.logger.info(`   Successfully updated '${worktree.branch}' to match upstream.`);
+    } else {
+      const hasLocalChanges = await this.hasLocalChangesSinceLastSync(worktree.path);
+      if (!hasLocalChanges) {
+        this.logger.info(
+          `\u2705 Branch '${worktree.branch}' has diverged but you made no local changes. Resetting to upstream...`
+        );
+        await this.gitService.resetToUpstream(worktree.path, worktree.branch);
+        this.logger.info(`   Successfully updated '${worktree.branch}' to match upstream.`);
+      } else {
+        this.logger.info(`\u{1F512} Branch '${worktree.branch}' has diverged with local changes. Moving to diverged...`);
+        const divergedPath = await this.divergeWorktree(worktree.path, worktree.branch);
+        const relativePath = path5.relative(process.cwd(), divergedPath);
+        this.logger.info(`   Moved to: ${relativePath}`);
+        this.logger.info(`   Your local changes are preserved. To review:`);
+        this.logger.info(`     cd ${relativePath}`);
+        this.logger.info(`     git diff origin/${worktree.branch}`);
+        await this.gitService.removeWorktree(worktree.path);
+        await this.gitService.addWorktree(worktree.branch, worktree.path);
+        this.logger.info(`   Created fresh worktree from upstream at: ${worktree.path}`);
+      }
     }
-    else {
-        let config;
-        if ((0, cli_1.isInteractiveMode)(options)) {
-            config = await (0, interactive_1.promptForConfig)(options);
+  }
+  async hasLocalChangesSinceLastSync(worktreePath) {
+    try {
+      const metadata = await this.gitService.getWorktreeMetadata(worktreePath);
+      if (!metadata || !metadata.lastSyncCommit) {
+        return true;
+      }
+      const currentCommit = await this.gitService.getCurrentCommit(worktreePath);
+      return currentCommit !== metadata.lastSyncCommit;
+    } catch {
+      return true;
+    }
+  }
+  async divergeWorktree(worktreePath, branchName) {
+    const divergedBaseDir = path5.join(this.config.worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const uniqueSuffix = Date.now().toString(36) + Math.random().toString(36).substring(2, 7);
+    const safeBranchName = branchName.replace(/\//g, "-");
+    const divergedName = `${timestamp}-${safeBranchName}-${uniqueSuffix}`;
+    const divergedPath = path5.join(divergedBaseDir, divergedName);
+    await fs5.mkdir(divergedBaseDir, { recursive: true });
+    try {
+      await fs5.rename(worktreePath, divergedPath);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("EXDEV")) {
+        await fs5.cp(worktreePath, divergedPath, { recursive: true });
+        await fs5.rm(worktreePath, { recursive: true, force: true });
+      } else {
+        throw err;
+      }
+    }
+    const metadata = {
+      originalBranch: branchName,
+      divergedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: METADATA_CONSTANTS.DIVERGED_REASON,
+      originalPath: worktreePath,
+      localCommit: await this.gitService.getCurrentCommit(divergedPath),
+      remoteCommit: await this.gitService.getRemoteCommit(`origin/${branchName}`),
+      instruction: `To preserve your changes:
+  1. Review: git diff origin/${branchName}
+  2. Keep changes: git push --force-with-lease origin ${branchName}
+  3. Discard changes: rm -rf this directory
+
+  Original worktree location: ${worktreePath}`
+    };
+    await fs5.writeFile(
+      path5.join(divergedPath, METADATA_CONSTANTS.DIVERGED_INFO_FILE),
+      JSON.stringify(metadata, null, 2)
+    );
+    return divergedPath;
+  }
+};
+
+// src/utils/disk-space.ts
+import fastFolderSize from "fast-folder-size";
+async function calculateDirectorySize(dirPath) {
+  return new Promise((resolve6) => {
+    fastFolderSize(dirPath, (err, bytes) => {
+      if (err || bytes === void 0) {
+        resolve6(0);
+      } else {
+        resolve6(bytes);
+      }
+    });
+  });
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const k = 1024;
+  const decimals = 2;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const value = bytes / Math.pow(k, i);
+  return `${value.toFixed(decimals)} ${units[i]}`;
+}
+async function calculateSyncDiskSpace(repoPaths, worktreeDirs) {
+  try {
+    let totalBytes = 0;
+    for (const repoPath of repoPaths) {
+      const bareSize = await calculateDirectorySize(repoPath);
+      totalBytes += bareSize;
+    }
+    for (const worktreeDir of worktreeDirs) {
+      const worktreeSize = await calculateDirectorySize(worktreeDir);
+      totalBytes += worktreeSize;
+    }
+    return formatBytes(totalBytes);
+  } catch (error) {
+    console.error("Failed to calculate disk space:", error);
+    return "N/A";
+  }
+}
+
+// src/services/InteractiveUIService.tsx
+var InteractiveUIService = class {
+  app = null;
+  syncServices;
+  configPath;
+  cronSchedule;
+  cronJobs = [];
+  repositoryCount;
+  originalConsoleLog;
+  originalConsoleWarn;
+  originalConsoleError;
+  constructor(syncServices, configPath, cronSchedule) {
+    if (syncServices.length === 0) {
+      throw new Error("InteractiveUIService requires at least one WorktreeSyncService");
+    }
+    this.syncServices = syncServices;
+    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.renderUI();
+  }
+  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);
+    };
+  }
+  restoreConsole() {
+    console.log = this.originalConsoleLog;
+    console.warn = this.originalConsoleWarn;
+    console.error = this.originalConsoleError;
+  }
+  setupCronJobs() {
+    if (!this.cronSchedule) {
+      return;
+    }
+    for (const service of this.syncServices) {
+      if (service.config.runOnce) {
+        continue;
+      }
+      const schedule3 = service.config.cronSchedule || this.cronSchedule;
+      const task = cron.schedule(schedule3, async () => {
+        this.setStatus("syncing");
+        try {
+          await service.sync();
+        } catch (error) {
+          console.error(`Error syncing: ${error.message}`);
+        } finally {
+          this.setStatus("idle");
         }
-        else {
-            config = options;
+        this.updateLastSyncTime();
+        await this.calculateAndUpdateDiskSpace();
+      });
+      this.cronJobs.push(task);
+    }
+  }
+  cancelCronJobs() {
+    for (const job of this.cronJobs) {
+      job.stop();
+    }
+    this.cronJobs = [];
+  }
+  renderUI() {
+    if (this.app) {
+      this.app.unmount();
+    }
+    this.app = render(
+      /* @__PURE__ */ React4.createElement(
+        App_default,
+        {
+          repositoryCount: this.repositoryCount,
+          cronSchedule: this.cronSchedule,
+          onManualSync: () => this.handleManualSync(),
+          onReload: () => this.handleReload(),
+          onQuit: () => this.handleQuit()
         }
-        // Convert noUpdateExisting CLI flag to updateExistingWorktrees config
-        if (options.noUpdateExisting) {
-            config.updateExistingWorktrees = false;
+      )
+    );
+  }
+  async handleManualSync() {
+    this.setStatus("syncing");
+    try {
+      for (const service of this.syncServices) {
+        await service.sync();
+      }
+      this.updateLastSyncTime();
+      await this.calculateAndUpdateDiskSpace();
+    } catch (error) {
+      console.error("Manual sync failed:", error);
+    } finally {
+      this.setStatus("idle");
+    }
+  }
+  async handleReload() {
+    try {
+      if (!this.configPath) {
+        this.setStatus("idle");
+        return;
+      }
+      await this.waitForInProgressSyncs();
+      this.cancelCronJobs();
+      console.log("Reloading configuration...");
+      this.setStatus("syncing");
+      const configLoader = new ConfigLoaderService();
+      const configFile = await configLoader.loadConfigFile(this.configPath);
+      const newServices = [];
+      for (const repoConfig of configFile.repositories) {
+        try {
+          const service = new WorktreeSyncService(repoConfig);
+          await service.initialize();
+          newServices.push(service);
+        } catch (error) {
+          console.error(`Failed to initialize repository ${repoConfig.name}: ${error.message}`);
+        }
+      }
+      if (newServices.length === 0) {
+        throw new Error("No repositories could be initialized from the configuration");
+      }
+      this.syncServices = newServices;
+      this.repositoryCount = this.syncServices.length;
+      this.setupCronJobs();
+      const failures = [];
+      for (const service of this.syncServices) {
+        try {
+          await service.sync();
+        } catch (error) {
+          const repoName = service.config.name || service.config.repoUrl;
+          const errorMessage = error.message;
+          console.error(`Failed to sync repository ${repoName}: ${errorMessage}`);
+          failures.push({ repo: repoName, error: errorMessage });
         }
-        else if (config.updateExistingWorktrees === undefined) {
-            config.updateExistingWorktrees = true; // Default to true
+      }
+      this.renderUI();
+      this.updateLastSyncTime();
+      await this.calculateAndUpdateDiskSpace();
+      this.setStatus("idle");
+      if (failures.length > 0) {
+        console.warn(`Reload completed with ${failures.length} repository failure(s)`);
+      }
+    } catch (error) {
+      console.error(`Reload failed: ${error.message}`);
+      this.setupCronJobs();
+      this.setStatus("idle");
+    }
+  }
+  async handleQuit() {
+    await this.waitForInProgressSyncs();
+    this.destroy();
+    process.exit(0);
+  }
+  async waitForInProgressSyncs() {
+    const inProgressServices = this.syncServices.filter((s) => s.isSyncInProgress());
+    if (inProgressServices.length === 0) {
+      return;
+    }
+    const syncChecks = inProgressServices.map(async (service) => {
+      const timeout = 3e4;
+      const checkInterval = 500;
+      const startTime = Date.now();
+      while (service.isSyncInProgress()) {
+        if (Date.now() - startTime > timeout) {
+          throw new Error("Timeout waiting for sync operations to complete");
         }
-        await runSingleRepository(config);
+        await new Promise((resolve6) => setTimeout(resolve6, checkInterval));
+      }
+    });
+    try {
+      await Promise.all(syncChecks);
+    } catch (error) {
+    }
+  }
+  updateLastSyncTime() {
+    const methods = globalThis.__inkAppMethods;
+    if (methods && methods.updateLastSyncTime) {
+      methods.updateLastSyncTime();
+    }
+  }
+  setStatus(status) {
+    const methods = globalThis.__inkAppMethods;
+    if (methods && methods.setStatus) {
+      methods.setStatus(status);
+    }
+  }
+  setDiskSpace(diskSpace) {
+    const methods = globalThis.__inkAppMethods;
+    if (methods && methods.setDiskSpace) {
+      methods.setDiskSpace(diskSpace);
+    }
+  }
+  async calculateAndUpdateDiskSpace() {
+    try {
+      const bareRepoDirs = this.syncServices.map(
+        (service) => service.config.bareRepoDir || getDefaultBareRepoDir(service.config.repoUrl)
+      );
+      const worktreeDirs = this.syncServices.map((service) => service.config.worktreeDir);
+      const diskSpace = await calculateSyncDiskSpace(bareRepoDirs, worktreeDirs);
+      this.setDiskSpace(diskSpace);
+    } catch (error) {
+      console.error("Failed to calculate disk space:", error);
+      this.setDiskSpace("N/A");
     }
+  }
+  destroy() {
+    this.cancelCronJobs();
+    this.restoreConsole();
+    if (this.app) {
+      this.app.unmount();
+      this.app = null;
+    }
+    delete globalThis.__inkAppMethods;
+  }
+};
+
+// src/utils/cli.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+function parseArguments() {
+  const argv = yargs(hideBin(process.argv)).option("config", {
+    alias: "c",
+    type: "string",
+    description: "Path to JavaScript config file"
+  }).option("filter", {
+    alias: "f",
+    type: "string",
+    description: "Filter repositories by name (supports wildcards and comma-separated values)"
+  }).option("list", {
+    alias: "l",
+    type: "boolean",
+    description: "List configured repositories and exit",
+    default: false
+  }).option("bareRepoDir", {
+    alias: "b",
+    type: "string",
+    description: "Directory for storing bare repositories (default: .bare/<repo-name>)."
+  }).option("repoUrl", {
+    alias: "u",
+    type: "string",
+    description: "Git repository URL (e.g., SSH or HTTPS)."
+  }).option("worktreeDir", {
+    alias: "w",
+    type: "string",
+    description: "Absolute path to the directory for storing worktrees."
+  }).option("cronSchedule", {
+    alias: "s",
+    type: "string",
+    description: "Cron schedule for how often to run the sync.",
+    default: "0 * * * *"
+  }).option("runOnce", {
+    type: "boolean",
+    description: "Run the sync process once and then exit, without scheduling.",
+    default: false
+  }).option("branchMaxAge", {
+    alias: "a",
+    type: "string",
+    description: "Maximum age of branches to sync (e.g., '30d', '6m', '1y')."
+  }).option("skipLfs", {
+    type: "boolean",
+    description: "Skip Git LFS downloads when fetching and creating worktrees.",
+    default: false
+  }).option("no-update-existing", {
+    type: "boolean",
+    description: "Disable automatic updates of existing worktrees.",
+    default: false
+  }).option("debug", {
+    alias: "d",
+    type: "boolean",
+    description: "Enable debug mode to show detailed reasons why worktrees are not cleaned up.",
+    default: false
+  }).help().alias("help", "h").parseSync();
+  return {
+    config: argv.config,
+    filter: argv.filter,
+    list: argv.list,
+    repoUrl: argv.repoUrl,
+    worktreeDir: argv.worktreeDir,
+    cronSchedule: argv.cronSchedule,
+    runOnce: argv.runOnce,
+    bareRepoDir: argv.bareRepoDir,
+    branchMaxAge: argv.branchMaxAge,
+    skipLfs: argv.skipLfs,
+    noUpdateExisting: argv["no-update-existing"],
+    debug: argv.debug
+  };
 }
-main().catch((error) => {
-    console.error("❌ Unhandled error:", error);
+function isInteractiveMode(config) {
+  return !config.repoUrl || !config.worktreeDir;
+}
+function reconstructCliCommand(config) {
+  const executable = process.argv[1].includes("ts-node") ? "ts-node src/index.ts" : "sync-worktrees";
+  const args = [];
+  args.push(`--repoUrl "${config.repoUrl}"`);
+  if (config.worktreeDir) {
+    args.push(`--worktreeDir "${config.worktreeDir}"`);
+  }
+  if (config.bareRepoDir) {
+    args.push(`--bareRepoDir "${config.bareRepoDir}"`);
+  }
+  if (config.cronSchedule && config.cronSchedule !== "0 * * * *") {
+    args.push(`--cronSchedule "${config.cronSchedule}"`);
+  }
+  if (config.runOnce) {
+    args.push("--runOnce");
+  }
+  if (config.branchMaxAge) {
+    args.push(`--branchMaxAge "${config.branchMaxAge}"`);
+  }
+  if (config.skipLfs) {
+    args.push("--skip-lfs");
+  }
+  if (config.updateExistingWorktrees === false) {
+    args.push("--no-update-existing");
+  }
+  if (config.debug) {
+    args.push("--debug");
+  }
+  return `${executable} ${args.join(" ")}`;
+}
+
+// src/utils/interactive.ts
+import * as path7 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";
+function serializeToESM(obj, indent = 0) {
+  const spaces = " ".repeat(indent);
+  const innerSpaces = " ".repeat(indent + 2);
+  if (typeof obj === "string") {
+    return `"${obj}"`;
+  }
+  if (typeof obj === "number" || typeof obj === "boolean") {
+    return String(obj);
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    const items = obj.map((item) => `${innerSpaces}${serializeToESM(item, indent + 2)}`).join(",\n");
+    return `[
+${items}
+${spaces}]`;
+  }
+  if (obj && typeof obj === "object") {
+    const entries = Object.entries(obj).filter(([_, value]) => value !== void 0).map(([key, value]) => {
+      const serializedValue = serializeToESM(value, indent + 2);
+      return `${innerSpaces}${key}: ${serializedValue}`;
+    });
+    if (entries.length === 0) return "{}";
+    return `{
+${entries.join(",\n")}
+${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 useRelativeWorktree = !worktreeDirRelative.startsWith("../../../");
+  const repoName = extractRepoNameFromUrl(config.repoUrl);
+  const repository = {
+    name: repoName,
+    repoUrl: config.repoUrl,
+    worktreeDir: useRelativeWorktree ? `./${worktreeDirRelative}` : config.worktreeDir
+  };
+  if (config.bareRepoDir) {
+    const bareRepoDirRelative = path6.relative(configDir, config.bareRepoDir);
+    const useRelativeBare = !bareRepoDirRelative.startsWith("../../../");
+    repository.bareRepoDir = useRelativeBare ? `./${bareRepoDirRelative}` : config.bareRepoDir;
+  }
+  const configObject = {
+    defaults: {
+      cronSchedule: config.cronSchedule,
+      runOnce: config.runOnce
+    },
+    repositories: [repository]
+  };
+  const configContent = `/**
+ * Sync-worktrees configuration file
+ * Generated on ${(/* @__PURE__ */ new Date()).toISOString()}
+ */
+
+export default ${serializeToESM(configObject)};
+`;
+  await fs6.writeFile(configPath, configContent, "utf-8");
+}
+function getDefaultConfigPath() {
+  return path6.join(process.cwd(), "sync-worktrees.config.js");
+}
+
+// src/utils/interactive.ts
+async function promptForConfig(partialConfig) {
+  console.log("\u{1F527} Welcome to sync-worktrees interactive setup!\n");
+  let repoUrl = partialConfig.repoUrl;
+  if (!repoUrl) {
+    repoUrl = await input({
+      message: "Enter the Git repository URL (e.g., https://github.com/user/repo.git):",
+      validate: (value) => {
+        if (!value.trim()) {
+          return "Repository URL is required";
+        }
+        try {
+          if (!value.match(/^(https?:\/\/|ssh:\/\/|git@|file:\/\/).*$/)) {
+            return "Please enter a valid Git URL (https://, ssh://, git@, or file://)";
+          }
+          return true;
+        } catch {
+          return "Please enter a valid URL";
+        }
+      }
+    });
+  }
+  let worktreeDir = partialConfig.worktreeDir;
+  if (!worktreeDir) {
+    const repoName = repoUrl ? extractRepoNameFromUrl(repoUrl) : "";
+    const defaultWorktreeDir = repoName ? `./${repoName}` : "";
+    worktreeDir = await input({
+      message: "Enter the directory for storing worktrees:",
+      default: defaultWorktreeDir,
+      validate: (value) => {
+        if (!value.trim() && !defaultWorktreeDir) {
+          return "Worktree directory is required";
+        }
+        return true;
+      }
+    });
+    if (!worktreeDir.trim() && defaultWorktreeDir) {
+      worktreeDir = defaultWorktreeDir;
+    }
+    if (!path7.isAbsolute(worktreeDir)) {
+      worktreeDir = path7.resolve(worktreeDir);
+    }
+  }
+  let bareRepoDir = partialConfig.bareRepoDir;
+  const askForBareDir = await confirm({
+    message: "Would you like to specify a custom location for the bare repository?",
+    default: false
+  });
+  if (askForBareDir) {
+    bareRepoDir = await input({
+      message: "Enter the directory for the bare repository:",
+      default: "",
+      validate: (value) => {
+        if (!value.trim()) {
+          return "Bare repository directory is required";
+        }
+        return true;
+      }
+    });
+    if (!path7.isAbsolute(bareRepoDir)) {
+      bareRepoDir = path7.resolve(bareRepoDir);
+    }
+  }
+  let runOnce = partialConfig.runOnce;
+  let cronSchedule = partialConfig.cronSchedule || "0 * * * *";
+  if (runOnce === void 0) {
+    const runMode = await select({
+      message: "How would you like to run the sync?",
+      choices: [
+        { name: "Run once", value: "once" },
+        { name: "Schedule with cron", value: "scheduled" }
+      ]
+    });
+    runOnce = runMode === "once";
+    if (!runOnce && !partialConfig.cronSchedule) {
+      cronSchedule = await input({
+        message: "Enter the cron schedule (or press enter for default):",
+        default: "0 * * * *",
+        validate: (value) => {
+          if (!value.trim()) {
+            return "Cron schedule is required";
+          }
+          const parts = value.trim().split(" ");
+          if (parts.length < 5) {
+            return "Invalid cron pattern. Expected format: '* * * * *'";
+          }
+          return true;
+        }
+      });
+    }
+  }
+  const finalConfig = {
+    repoUrl,
+    worktreeDir,
+    cronSchedule,
+    runOnce: runOnce || false,
+    bareRepoDir
+  };
+  console.log("\n\u{1F4CB} Configuration summary:");
+  console.log(`   Repository URL: ${finalConfig.repoUrl}`);
+  console.log(`   Worktrees:      ${finalConfig.worktreeDir}`);
+  if (finalConfig.bareRepoDir) {
+    console.log(`   Bare repo:      ${finalConfig.bareRepoDir}`);
+  } else {
+    console.log(`   Bare repo:      .bare/<repo-name> (default)`);
+  }
+  if (finalConfig.runOnce) {
+    console.log(`   Mode:           Run once`);
+  } else {
+    console.log(`   Mode:           Scheduled (${finalConfig.cronSchedule})`);
+  }
+  console.log("");
+  const saveConfig = await confirm({
+    message: "Would you like to save this configuration to a file for future use?",
+    default: true
+  });
+  if (saveConfig) {
+    const defaultConfigPath = getDefaultConfigPath();
+    let configPath = await input({
+      message: "Enter the path for the config file:",
+      default: defaultConfigPath,
+      validate: (value) => {
+        if (!value.trim()) {
+          return "Config file path is required";
+        }
+        if (!value.endsWith(".js")) {
+          return "Config file must have a .js extension";
+        }
+        return true;
+      }
+    });
+    if (!path7.isAbsolute(configPath)) {
+      configPath = path7.resolve(configPath);
+    }
+    try {
+      await generateConfigFile(finalConfig, configPath);
+      console.log(`
+\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("");
+    } catch (error) {
+      console.error(`
+\u274C Failed to save config file: ${error.message}`);
+    }
+  }
+  return finalConfig;
+}
+
+// src/index.ts
+async function runSingleRepository(config) {
+  const logger = Logger.createDefault(void 0, config.debug);
+  logger.info("\n\u{1F4CB} CLI Command (for future reference):");
+  logger.info(`   ${reconstructCliCommand(config)}`);
+  logger.info("");
+  if (!config.logger) {
+    config.logger = logger;
+  }
+  const syncService = new WorktreeSyncService(config);
+  try {
+    await syncService.initialize();
+    if (config.runOnce) {
+      logger.info("Running the sync process once as requested by --runOnce flag.");
+      await syncService.sync();
+    } else {
+      const uiService = new InteractiveUIService([syncService], void 0, config.cronSchedule);
+      await syncService.sync();
+      uiService.updateLastSyncTime();
+      void uiService.calculateAndUpdateDiskSpace();
+      cron2.schedule(config.cronSchedule, async () => {
+        try {
+          uiService.setStatus("syncing");
+          await syncService.sync();
+          uiService.updateLastSyncTime();
+          void uiService.calculateAndUpdateDiskSpace();
+        } catch (error) {
+          logger.error(`Error during scheduled sync: ${error.message}`, error);
+          uiService.setStatus("idle");
+        }
+      });
+    }
+  } catch (error) {
+    logger.error("\u274C Fatal Error during initialization:", error);
     process.exit(1);
+  }
+}
+async function runMultipleRepositories(repositories, runOnce, configPath, maxParallel) {
+  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(`
+\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);
+    }
+  }
+  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) {
+    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) {
+      const syncService = services.get(repoConfig.name);
+      if (!syncService) continue;
+      if (!cronJobs.has(repoConfig.cronSchedule)) {
+        cronJobs.set(repoConfig.cronSchedule, repoConfig.cronSchedule);
+        cron2.schedule(repoConfig.cronSchedule, async () => {
+          const reposToSync = repositories.filter((r) => r.cronSchedule === repoConfig.cronSchedule);
+          uiService.setStatus("syncing");
+          await Promise.allSettled(
+            reposToSync.map(
+              (repo) => limit(async () => {
+                const service = services.get(repo.name);
+                if (!service) return;
+                globalLogger.info(`Running scheduled sync for: ${repo.name}`);
+                try {
+                  await service.sync();
+                } catch (error) {
+                  globalLogger.error(`Error syncing '${repo.name}':`, error);
+                }
+              })
+            )
+          );
+          uiService.updateLastSyncTime();
+          void uiService.calculateAndUpdateDiskSpace();
+        });
+      }
+    }
+    globalLogger.info(`All ${repositories.length} repositories scheduled`);
+    for (const [schedule3] of cronJobs) {
+      const repoCount = repositories.filter((r) => r.cronSchedule === schedule3).length;
+      globalLogger.info(`${schedule3}: ${repoCount} repository(ies)`);
+    }
+  }
+}
+async function listRepositories(configPath, filter) {
+  const configLoader = new ConfigLoaderService();
+  try {
+    const configFile = await configLoader.loadConfigFile(configPath);
+    const configDir = path8.dirname(path8.resolve(configPath));
+    let repositories = configFile.repositories.map(
+      (repo) => configLoader.resolveRepositoryConfig(repo, configFile.defaults, configDir, configFile.retry)
+    );
+    if (filter) {
+      repositories = configLoader.filterRepositories(repositories, filter);
+      if (repositories.length === 0) {
+        console.error(`\u274C No repositories match filter: ${filter}`);
+        process.exit(1);
+      }
+    }
+    console.log("\n\u{1F4CB} Configured repositories:\n");
+    repositories.forEach((repo, index) => {
+      console.log(`${index + 1}. ${repo.name}`);
+      console.log(`   URL: ${repo.repoUrl}`);
+      console.log(`   Worktrees: ${repo.worktreeDir}`);
+      console.log(`   Schedule: ${repo.cronSchedule}`);
+      console.log(`   Run Once: ${repo.runOnce}`);
+      if (repo.bareRepoDir) {
+        console.log(`   Bare repo: ${repo.bareRepoDir}`);
+      }
+      if (repo.skipLfs) {
+        console.log(`   Skip LFS: ${repo.skipLfs}`);
+      }
+      console.log("");
+    });
+  } catch (error) {
+    console.error("\u274C Error loading config file:", error.message);
+    process.exit(1);
+  }
+}
+async function main() {
+  const options = parseArguments();
+  if (options.config) {
+    const configLoader = new ConfigLoaderService();
+    if (options.list) {
+      await listRepositories(options.config, options.filter);
+      return;
+    }
+    try {
+      const configFile = await configLoader.loadConfigFile(options.config);
+      const configDir = path8.dirname(path8.resolve(options.config));
+      let repositories = configFile.repositories.map(
+        (repo) => configLoader.resolveRepositoryConfig(repo, configFile.defaults, configDir, configFile.retry)
+      );
+      if (options.filter) {
+        repositories = configLoader.filterRepositories(repositories, options.filter);
+        if (repositories.length === 0) {
+          console.error(`\u274C No repositories match filter: ${options.filter}`);
+          process.exit(1);
+        }
+      }
+      const globalRunOnce = options.runOnce ?? configFile.defaults?.runOnce ?? false;
+      if (options.noUpdateExisting) {
+        repositories = repositories.map((repo) => ({
+          ...repo,
+          updateExistingWorktrees: false
+        }));
+      }
+      if (options.debug) {
+        repositories = repositories.map((repo) => ({
+          ...repo,
+          debug: true
+        }));
+      }
+      const maxParallel = configFile.parallelism?.maxRepositories ?? configFile.defaults?.parallelism?.maxRepositories ?? DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES;
+      await runMultipleRepositories(repositories, globalRunOnce, options.config, maxParallel);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Config file not found")) {
+        console.error(`
+\u274C Config file not found: ${options.config}`);
+        const createConfig = await confirm2({
+          message: "Would you like to run interactive setup to create a config file?",
+          default: true
+        });
+        if (createConfig) {
+          const config = await promptForConfig({});
+          await runSingleRepository(config);
+        } else {
+          console.log("\n\u{1F4A1} You can create a config file manually or run without --config for interactive setup.");
+          process.exit(1);
+        }
+      } else {
+        console.error("\u274C Error loading config file:", error.message);
+        process.exit(1);
+      }
+    }
+  } else {
+    let config;
+    if (isInteractiveMode(options)) {
+      config = await promptForConfig(options);
+    } else {
+      config = options;
+    }
+    if (options.noUpdateExisting) {
+      config.updateExistingWorktrees = false;
+    } else if (config.updateExistingWorktrees === void 0) {
+      config.updateExistingWorktrees = true;
+    }
+    if (options.debug !== void 0) {
+      config.debug = options.debug;
+    }
+    await runSingleRepository(config);
+  }
+}
+main().catch((error) => {
+  console.error("\u274C Unhandled error:", error);
+  process.exit(1);
 });
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map