branch-nexus 1.0.0

package/dist/cli.js

@@ -0,0 +1,3651 @@
+#!/usr/bin/env node
+import * as path2 from 'path';
+import { join, basename, resolve, dirname } from 'path';
+import 'url';
+import { readFileSync, existsSync, readdirSync, mkdirSync, appendFileSync } from 'fs';
+import * as os from 'os';
+import { homedir } from 'os';
+import simpleGit2 from 'simple-git';
+import { Command } from 'commander';
+import chalk9 from 'chalk';
+import * as p3 from '@clack/prompts';
+import { z } from 'zod';
+import Conf from 'conf';
+import { execa } from 'execa';
+import inquirer2 from 'inquirer';
+import * as readline from 'readline';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
+
+// ts-src/types/errors.ts
+function userFacingError(message, hint) {
+  if (hint !== void 0 && hint !== "") {
+    return `Error: ${message}. Next step: ${hint}`;
+  }
+  return `Error: ${message}.`;
+}
+function isBranchNexusError(error) {
+  return error instanceof BranchNexusError;
+}
+var BranchNexusError;
+var init_errors = __esm({
+  "ts-src/types/errors.ts"() {
+    init_esm_shims();
+    BranchNexusError = class extends Error {
+      code;
+      hint;
+      constructor(message, code = 4 /* RUNTIME_ERROR */, hint = "") {
+        super(message);
+        this.name = "BranchNexusError";
+        this.code = code;
+        this.hint = hint;
+      }
+      toString() {
+        if (this.hint !== "") {
+          return `${this.message} Hint: ${this.hint}`;
+        }
+        return this.message;
+      }
+    };
+  }
+});
+function defaultLogPath() {
+  const logDir = resolve(homedir(), DEFAULT_LOG_DIR);
+  return resolve(logDir, DEFAULT_LOG_FILE);
+}
+function configureLogging(options) {
+  if (options?.level !== void 0) {
+    currentLevel = options.level;
+  }
+  if (options?.logFile !== void 0 && options.logFile !== "") {
+    logFilePath = resolve(options.logFile);
+    const logDir = dirname(logFilePath);
+    if (!existsSync(logDir)) {
+      mkdirSync(logDir, { recursive: true });
+    }
+  }
+}
+function formatMessage(level, message, args) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const formattedArgs = args.length > 0 ? " " + args.map((arg) => JSON.stringify(arg)).join(" ") : "";
+  return `${timestamp} ${level.toUpperCase()} ${message}${formattedArgs}`;
+}
+function log(level, message, args) {
+  if (LOG_LEVELS[level] < LOG_LEVELS[currentLevel]) {
+    return;
+  }
+  const formatted = formatMessage(level, message, args);
+  if (level === "error") {
+    console.error(formatted);
+  } else if (level === "warn") {
+    console.warn(formatted);
+  } else {
+    console.log(formatted);
+  }
+  if (logFilePath !== null) {
+    try {
+      appendFileSync(logFilePath, formatted + "\n", "utf-8");
+    } catch {
+    }
+  }
+}
+var LOG_LEVELS, currentLevel, logFilePath, DEFAULT_LOG_DIR, DEFAULT_LOG_FILE, logger;
+var init_logger = __esm({
+  "ts-src/utils/logger.ts"() {
+    init_esm_shims();
+    LOG_LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    currentLevel = "info";
+    logFilePath = null;
+    DEFAULT_LOG_DIR = ".config/branchnexus/logs";
+    DEFAULT_LOG_FILE = "branchnexus.log";
+    logger = {
+      debug: (message, ...args) => {
+        log("debug", message, args);
+      },
+      info: (message, ...args) => {
+        log("info", message, args);
+      },
+      warn: (message, ...args) => {
+        log("warn", message, args);
+      },
+      error: (message, ...args) => {
+        log("error", message, args);
+      }
+    };
+  }
+});
+
+// ts-src/git/branch.ts
+var branch_exports = {};
+__export(branch_exports, {
+  branchExists: () => branchExists,
+  getCurrentBranch: () => getCurrentBranch,
+  listLocalBranches: () => listLocalBranches,
+  remoteBranchExists: () => remoteBranchExists
+});
+async function listLocalBranches(repoPath) {
+  logger.debug(`Listing local branches for ${repoPath}`);
+  const git = simpleGit2(repoPath);
+  try {
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+      throw new BranchNexusError(
+        `Not a git repository: ${repoPath}`,
+        5 /* GIT_ERROR */,
+        "Check the path and ensure it is a valid Git repository."
+      );
+    }
+  } catch (error) {
+    if (error instanceof BranchNexusError) {
+      throw error;
+    }
+    throw new BranchNexusError(
+      `Repository is not accessible: ${repoPath}`,
+      5 /* GIT_ERROR */,
+      "Check the path and ensure it is a valid Git repository."
+    );
+  }
+  let warning;
+  try {
+    const status = await git.status();
+    if (status.detached) {
+      warning = "Detached HEAD detected. Branch operations may be limited.";
+      logger.warn(`Detached HEAD detected repo=${repoPath}`);
+    }
+  } catch {
+  }
+  try {
+    const localBranches = await git.branchLocal();
+    const FORK_BRANCH_RE = /-pane-\d+$/;
+    let branchNames = localBranches.all.filter((b) => !FORK_BRANCH_RE.test(b)).sort();
+    try {
+      await git.fetch(["--all"]);
+      const remoteBranches = await git.branch(["-r"]);
+      const remoteNames = remoteBranches.all.filter((b) => !b.includes("HEAD") && !FORK_BRANCH_RE.test(b)).sort();
+      branchNames = [...branchNames, ...remoteNames];
+      logger.debug(
+        `Discovered ${localBranches.all.length} local + ${remoteNames.length} remote branches`
+      );
+    } catch (fetchError) {
+      logger.debug("Could not fetch remote branches");
+    }
+    if (branchNames.length === 0) {
+      throw new BranchNexusError(
+        "No branches found.",
+        5 /* GIT_ERROR */,
+        "Create an initial commit and at least one branch."
+      );
+    }
+    logger.debug(`Total ${branchNames.length} branches available`);
+    return {
+      branches: branchNames,
+      warning
+    };
+  } catch (error) {
+    if (error instanceof BranchNexusError) {
+      throw error;
+    }
+    throw new BranchNexusError(
+      `Failed to list branches for ${repoPath}`,
+      5 /* GIT_ERROR */,
+      "Run `git branch -a` manually to inspect repository state."
+    );
+  }
+}
+async function getCurrentBranch(repoPath) {
+  const git = simpleGit2(repoPath);
+  const status = await git.status();
+  return status.current ?? "HEAD";
+}
+async function branchExists(repoPath, branch) {
+  const git = simpleGit2(repoPath);
+  const branches = await git.branchLocal();
+  return branches.all.includes(branch);
+}
+async function remoteBranchExists(repoPath, remoteBranch) {
+  const git = simpleGit2(repoPath);
+  const branches = await git.branch(["-r"]);
+  return branches.all.includes(remoteBranch);
+}
+var init_branch = __esm({
+  "ts-src/git/branch.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_errors();
+  }
+});
+
+// ts-src/cli.ts
+init_esm_shims();
+
+// ts-src/commands/index.ts
+init_esm_shims();
+
+// ts-src/commands/run.ts
+init_esm_shims();
+init_errors();
+
+// ts-src/core/config.ts
+init_esm_shims();
+
+// ts-src/types/index.ts
+init_esm_shims();
+
+// ts-src/types/config.ts
+init_esm_shims();
+var LayoutSchema = z.enum(["horizontal", "vertical", "grid"]);
+var CleanupPolicySchema = z.enum(["session", "persistent"]);
+var ColorThemeSchema = z.enum(["cyan", "green", "magenta", "blue", "yellow", "red"]);
+var TerminalRuntimeSchema = z.enum(["wsl", "powershell", "native"]);
+var RepositoryCacheEntrySchema = z.object({
+  full_name: z.string(),
+  clone_url: z.string()
+});
+var PresetConfigSchema = z.object({
+  layout: LayoutSchema,
+  panes: z.number().int().min(2).max(6),
+  cleanup: CleanupPolicySchema
+});
+var AppConfigSchema = z.object({
+  defaultRoot: z.string().default(""),
+  remoteRepoUrl: z.string().default(""),
+  githubToken: z.string().default(""),
+  githubRepositoriesCache: z.array(RepositoryCacheEntrySchema).default([]),
+  githubBranchesCache: z.record(z.array(z.string())).default({}),
+  defaultLayout: LayoutSchema.default("grid"),
+  defaultPanes: z.number().int().min(2).max(6).default(4),
+  cleanupPolicy: CleanupPolicySchema.default("session"),
+  tmuxAutoInstall: z.boolean().default(true),
+  wslDistribution: z.string().default(""),
+  terminalDefaultRuntime: TerminalRuntimeSchema.default("wsl"),
+  terminalMaxCount: z.number().int().min(2).max(16).default(16),
+  sessionRestoreEnabled: z.boolean().default(true),
+  lastSession: z.record(z.unknown()).default({}),
+  colorTheme: ColorThemeSchema.default("cyan"),
+  presets: z.record(PresetConfigSchema).default({}),
+  commandHooks: z.record(z.array(z.string())).default({})
+});
+var DEFAULT_CONFIG = {
+  defaultRoot: "",
+  remoteRepoUrl: "",
+  githubToken: "",
+  githubRepositoriesCache: [],
+  githubBranchesCache: {},
+  defaultLayout: "grid",
+  defaultPanes: 4,
+  cleanupPolicy: "session",
+  tmuxAutoInstall: true,
+  wslDistribution: "",
+  terminalDefaultRuntime: "wsl",
+  terminalMaxCount: 16,
+  sessionRestoreEnabled: true,
+  lastSession: {},
+  colorTheme: "cyan",
+  presets: {},
+  commandHooks: {}
+};
+
+// ts-src/types/index.ts
+init_errors();
+
+// ts-src/types/worktree.ts
+init_esm_shims();
+function createWorktreeAssignment(pane, repoPath, branch) {
+  return { pane, repoPath, branch };
+}
+function createManagedWorktree(assignment, path3) {
+  return {
+    pane: assignment.pane,
+    repoPath: assignment.repoPath,
+    branch: assignment.branch,
+    path: path3
+  };
+}
+
+// ts-src/types/session.ts
+init_esm_shims();
+function isSessionSnapshot(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const snapshot = value;
+  return typeof snapshot["layout"] === "string" && typeof snapshot["templateCount"] === "number" && Array.isArray(snapshot["terminals"]);
+}
+
+// ts-src/core/config.ts
+init_errors();
+var GITHUB_TOKEN_ENV = "BRANCHNEXUS_GH_TOKEN";
+var configStore = new Conf({
+  projectName: "branchnexus",
+  configName: "config",
+  defaults: DEFAULT_CONFIG,
+  schema: {
+    defaultRoot: { type: "string" },
+    remoteRepoUrl: { type: "string" },
+    githubToken: { type: "string" },
+    githubRepositoriesCache: { type: "array" },
+    githubBranchesCache: { type: "object" },
+    defaultLayout: { type: "string", enum: ["horizontal", "vertical", "grid"] },
+    defaultPanes: { type: "number", minimum: 2, maximum: 6 },
+    cleanupPolicy: { type: "string", enum: ["session", "persistent"] },
+    tmuxAutoInstall: { type: "boolean" },
+    wslDistribution: { type: "string" },
+    terminalDefaultRuntime: { type: "string", enum: ["wsl", "powershell", "native"] },
+    terminalMaxCount: { type: "number", minimum: 2, maximum: 16 },
+    sessionRestoreEnabled: { type: "boolean" },
+    lastSession: { type: "object" },
+    colorTheme: { type: "string", enum: ["cyan", "green", "magenta", "blue", "yellow", "red"] },
+    presets: { type: "object" },
+    commandHooks: { type: "object" }
+  }
+});
+function getConfigPath() {
+  return configStore.path;
+}
+function loadConfig() {
+  try {
+    const raw = configStore.store;
+    const config = AppConfigSchema.parse(raw);
+    const envToken = process.env[GITHUB_TOKEN_ENV];
+    if (envToken !== void 0 && envToken.trim() !== "") {
+      config.githubToken = envToken.trim();
+    }
+    return config;
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      throw new BranchNexusError(
+        "Configuration validation failed",
+        3 /* CONFIG_ERROR */,
+        error.message
+      );
+    }
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  const validated = AppConfigSchema.parse(config);
+  configStore.store = validated;
+}
+function resetConfig() {
+  configStore.store = DEFAULT_CONFIG;
+  return { ...DEFAULT_CONFIG };
+}
+function setWslDistribution(distribution) {
+  const config = loadConfig();
+  config.wslDistribution = distribution;
+  saveConfig(config);
+  return config;
+}
+function setGithubToken(token) {
+  const config = loadConfig();
+  config.githubToken = token;
+  saveConfig(config);
+  return config;
+}
+function updateGithubRepoCache(repos) {
+  const config = loadConfig();
+  config.githubRepositoriesCache = repos.map((repo) => ({
+    full_name: repo.full_name,
+    clone_url: repo.clone_url
+  }));
+  saveConfig(config);
+  return config;
+}
+function updateLastSession(session) {
+  const config = loadConfig();
+  config.lastSession = session;
+  saveConfig(config);
+  return config;
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  switch (key) {
+    case "defaultRoot":
+      config.defaultRoot = value;
+      break;
+    case "remoteRepoUrl":
+      config.remoteRepoUrl = value;
+      break;
+    case "githubToken":
+      config.githubToken = value;
+      break;
+    case "defaultLayout":
+      if (["horizontal", "vertical", "grid"].includes(value)) {
+        config.defaultLayout = value;
+      }
+      break;
+    case "defaultPanes":
+      config.defaultPanes = parseInt(value, 10);
+      break;
+    case "cleanupPolicy":
+      if (["session", "persistent"].includes(value)) {
+        config.cleanupPolicy = value;
+      }
+      break;
+    case "wslDistribution":
+      config.wslDistribution = value;
+      break;
+    case "terminalMaxCount":
+      config.terminalMaxCount = parseInt(value, 10);
+      break;
+    case "tmuxAutoInstall":
+      config.tmuxAutoInstall = value === "true";
+      break;
+    case "sessionRestoreEnabled":
+      config.sessionRestoreEnabled = value === "true";
+      break;
+    case "colorTheme":
+      if (["cyan", "green", "magenta", "blue", "yellow", "red"].includes(value)) {
+        config.colorTheme = value;
+      }
+      break;
+    default:
+      throw new BranchNexusError(
+        `Unknown config key: ${key}`,
+        3 /* CONFIG_ERROR */,
+        'Use "branchnexus config show" to see available keys.'
+      );
+  }
+  saveConfig(config);
+  return config;
+}
+
+// ts-src/core/orchestrator.ts
+init_esm_shims();
+init_errors();
+
+// ts-src/runtime/wsl.ts
+init_esm_shims();
+init_logger();
+init_errors();
+
+// ts-src/runtime/platform.ts
+init_esm_shims();
+function detectPlatform() {
+  const platform2 = os.platform();
+  if (platform2 === "win32") {
+    return "windows" /* WINDOWS */;
+  }
+  if (platform2 === "darwin") {
+    return "macos" /* MACOS */;
+  }
+  return "linux" /* LINUX */;
+}
+async function hasTmux() {
+  try {
+    await execa("tmux", ["-V"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function expandHomeDir(filepath) {
+  if (filepath.startsWith("~/")) {
+    return path2.join(os.homedir(), filepath.slice(2));
+  }
+  return filepath;
+}
+
+// ts-src/runtime/wsl.ts
+async function listDistributions() {
+  logger.debug("Listing WSL distributions using wsl.exe -l -q");
+  if (detectPlatform() !== "windows" /* WINDOWS */) {
+    throw new BranchNexusError(
+      "WSL is only available on Windows",
+      8 /* UNSUPPORTED_PLATFORM */,
+      "Use native tmux on this platform."
+    );
+  }
+  try {
+    const result = await execa("wsl.exe", ["-l", "-q"], {
+      encoding: "buffer"
+    });
+    const output = decodeWslOutput(result.stdout);
+    const distros = output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).sort();
+    if (distros.length === 0) {
+      throw new BranchNexusError(
+        "No WSL distributions were found.",
+        4 /* RUNTIME_ERROR */,
+        "Install a distribution using `wsl --install` and retry."
+      );
+    }
+    logger.debug(`Discovered ${distros.length} WSL distributions`);
+    return distros;
+  } catch (error) {
+    if (error instanceof BranchNexusError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BranchNexusError(
+      "Failed to list WSL distributions.",
+      4 /* RUNTIME_ERROR */,
+      message
+    );
+  }
+}
+function decodeWslOutput(buffer) {
+  if (buffer.includes(0)) {
+    try {
+      return buffer.toString("utf-16le").replace(/\ufeff/g, "");
+    } catch {
+    }
+  }
+  return buffer.toString("utf-8");
+}
+function validateDistribution(distribution, available) {
+  return available.includes(distribution);
+}
+function buildWslCommand(distribution, command) {
+  if (distribution === "") {
+    throw new BranchNexusError(
+      "WSL distribution is required.",
+      7 /* VALIDATION_ERROR */,
+      "Select a distribution before orchestration."
+    );
+  }
+  if (command.length === 0) {
+    throw new BranchNexusError(
+      "Runtime command is empty.",
+      7 /* VALIDATION_ERROR */,
+      "Provide a command to execute in WSL."
+    );
+  }
+  return ["wsl.exe", "-d", distribution, "--", ...command];
+}
+
+// ts-src/tmux/layouts.ts
+init_esm_shims();
+init_errors();
+var VALID_LAYOUTS = /* @__PURE__ */ new Set(["horizontal", "vertical", "grid"]);
+function validateLayout(layout, panes) {
+  if (!VALID_LAYOUTS.has(layout)) {
+    throw new BranchNexusError(
+      `Unsupported layout: ${layout}`,
+      7 /* VALIDATION_ERROR */,
+      "Use horizontal, vertical, or grid."
+    );
+  }
+  if (panes < 1 || panes > 6) {
+    throw new BranchNexusError(
+      `Invalid pane count: ${panes}`,
+      7 /* VALIDATION_ERROR */,
+      "Use a pane value between 1 and 6."
+    );
+  }
+}
+function buildLayoutCommands(sessionName, layout, panePaths, colorTheme, paneBranches, paneNames, startupCommands) {
+  const panes = panePaths.length;
+  validateLayout(layout, panes);
+  const tmuxColor = colorTheme ?? "cyan";
+  const commands = [
+    ["tmux", "new-session", "-d", "-s", sessionName, "-c", panePaths[0]],
+    ["tmux", "set-option", "-t", sessionName, "mouse", "on"],
+    ["tmux", "bind-key", "-n", "WheelUpPane", "send-keys", "-M"],
+    ["tmux", "bind-key", "-n", "WheelDownPane", "send-keys", "-M"],
+    // Apply color theme
+    ["tmux", "set-option", "-t", sessionName, "status-style", `bg=${tmuxColor},fg=black`],
+    ["tmux", "set-option", "-t", sessionName, "pane-border-style", `fg=${tmuxColor}`],
+    ["tmux", "set-option", "-t", sessionName, "pane-active-border-style", `fg=${tmuxColor},bold`],
+    ["tmux", "set-option", "-t", sessionName, "status-left", ` ${sessionName} `],
+    ["tmux", "set-option", "-t", sessionName, "status-left-style", `bg=${tmuxColor},fg=black,bold`],
+    ["tmux", "set-option", "-t", sessionName, "status-right", " %H:%M %d-%b-%y "],
+    ["tmux", "set-option", "-t", sessionName, "status-right-style", `bg=${tmuxColor},fg=black`],
+    ["tmux", "set-option", "-t", sessionName, "window-status-format", ""],
+    ["tmux", "set-option", "-t", sessionName, "window-status-current-format", ""],
+    // Pane border labels with blinking indicator for active pane
+    ["tmux", "set-option", "-t", sessionName, "pane-border-status", "top"],
+    [
+      "tmux",
+      "set-option",
+      "-t",
+      sessionName,
+      "pane-border-format",
+      `#{?pane_active,#[fg=${tmuxColor}#,blink] \u25CF #[noblink#,bold]#{pane_title} #[default],#[fg=grey] \u25CB #{pane_title} #[default]}`
+    ]
+  ];
+  function paneTitle(index) {
+    const customName = paneNames?.[index] ?? "";
+    const branch = paneBranches?.[index]?.replace(/^origin\//, "") ?? "";
+    if (customName !== "") return `${customName} [${branch}]`;
+    return `Pane ${index} [${branch}]`;
+  }
+  commands.push([
+    "tmux",
+    "select-pane",
+    "-t",
+    `${sessionName}:0.0`,
+    "-T",
+    paneTitle(0)
+  ]);
+  for (let index = 1; index < panes; index++) {
+    let splitFlag;
+    if (layout === "horizontal") {
+      splitFlag = "-h";
+    } else if (layout === "vertical") {
+      splitFlag = "-v";
+    } else {
+      splitFlag = index % 2 === 0 ? "-v" : "-h";
+    }
+    commands.push([
+      "tmux",
+      "split-window",
+      splitFlag,
+      "-t",
+      `${sessionName}:0`,
+      "-c",
+      panePaths[index]
+    ]);
+    commands.push([
+      "tmux",
+      "select-pane",
+      "-t",
+      `${sessionName}:0.${index}`,
+      "-T",
+      paneTitle(index)
+    ]);
+  }
+  let tmuxLayout;
+  if (layout === "horizontal") {
+    tmuxLayout = "even-horizontal";
+  } else if (layout === "vertical") {
+    tmuxLayout = "even-vertical";
+  } else {
+    tmuxLayout = "tiled";
+  }
+  commands.push(["tmux", "select-layout", "-t", `${sessionName}:0`, tmuxLayout]);
+  commands.push([
+    "tmux",
+    "set-hook",
+    "-t",
+    sessionName,
+    "client-resized",
+    `select-layout -t ${sessionName}:0 ${tmuxLayout}`
+  ]);
+  commands.push(["tmux", "select-pane", "-t", `${sessionName}:0.0`]);
+  if (startupCommands !== void 0 && startupCommands.length > 0) {
+    for (let i = 0; i < panes; i++) {
+      const cmd = startupCommands[i];
+      if (cmd !== void 0 && cmd.trim() !== "") {
+        commands.push([
+          "tmux",
+          "send-keys",
+          "-t",
+          `${sessionName}:0.${i}`,
+          cmd.trim(),
+          "Enter"
+        ]);
+      }
+    }
+  }
+  return commands;
+}
+
+// ts-src/tmux/session.ts
+init_esm_shims();
+
+// ts-src/runtime/shell.ts
+init_esm_shims();
+init_logger();
+init_errors();
+async function runCommand(command, options = {}) {
+  const [cmd, ...args] = command;
+  logger.debug(`Running command: ${command.join(" ")}`);
+  try {
+    const result = await execa(cmd, args, {
+      cwd: options.cwd,
+      timeout: options.timeout ?? 3e4,
+      input: options.input,
+      reject: false,
+      all: true
+    });
+    return {
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr
+    };
+  } catch (error) {
+    const execaError = error;
+    return {
+      exitCode: execaError.exitCode ?? 1,
+      stdout: execaError.stdout ?? "",
+      stderr: execaError.stderr ?? execaError.message
+    };
+  }
+}
+async function runCommandViaWSL(distribution, command, options = {}) {
+  const wrapped = buildWslCommand(distribution, command);
+  logger.debug(`Running WSL command: ${wrapped.join(" ")}`);
+  return runCommand(wrapped, options);
+}
+
+// ts-src/tmux/session.ts
+init_logger();
+init_errors();
+async function startSession(sessionName, commands, distribution) {
+  const isWindows = detectPlatform() === "windows" /* WINDOWS */;
+  logger.debug(`Starting tmux session: ${sessionName}`);
+  for (const command of commands) {
+    const wrappedCommand = isWindows && distribution !== void 0 && distribution !== "" ? buildWslCommand(distribution, command) : command;
+    logger.debug(`Executing tmux command: ${wrappedCommand.join(" ")}`);
+    const result = isWindows && distribution !== void 0 && distribution !== "" ? await runCommandViaWSL(distribution, command) : await runCommand(wrappedCommand);
+    if (result.exitCode !== 0) {
+      const stderr = result.stderr.trim();
+      const isNewSession = command[0] === "tmux" && command[1] === "new-session";
+      if (isNewSession && stderr.toLowerCase().includes("duplicate session")) {
+        logger.warn(`tmux session already exists: ${sessionName}, replacing`);
+        await killSession(sessionName, distribution);
+        const retryResult = isWindows && distribution !== void 0 && distribution !== "" ? await runCommandViaWSL(distribution, command) : await runCommand(wrappedCommand);
+        if (retryResult.exitCode !== 0) {
+          throw new BranchNexusError(
+            "Failed to initialize tmux session.",
+            6 /* TMUX_ERROR */,
+            retryResult.stderr || "tmux command failed"
+          );
+        }
+        continue;
+      }
+      throw new BranchNexusError(
+        "Failed to initialize tmux session.",
+        6 /* TMUX_ERROR */,
+        stderr || "tmux command failed"
+      );
+    }
+  }
+  logger.info(`tmux session ready: ${sessionName}`);
+}
+async function killSession(sessionName, distribution) {
+  const isWindows = detectPlatform() === "windows" /* WINDOWS */;
+  const command = ["tmux", "kill-session", "-t", sessionName];
+  logger.debug(`Killing tmux session: ${sessionName}`);
+  const result = isWindows && distribution !== void 0 && distribution !== "" ? await runCommandViaWSL(distribution, command) : await runCommand(command);
+  if (result.exitCode !== 0) {
+    logger.warn(`Failed to kill session: ${result.stderr}`);
+  }
+}
+async function listSessions(distribution) {
+  const isWindows = detectPlatform() === "windows" /* WINDOWS */;
+  const command = ["tmux", "list-sessions", "-F", "#{session_name}"];
+  try {
+    const result = isWindows && distribution !== void 0 && distribution !== "" ? await runCommandViaWSL(distribution, command) : await runCommand(command);
+    if (result.exitCode !== 0) {
+      return [];
+    }
+    return result.stdout.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+// ts-src/git/worktree.ts
+init_esm_shims();
+init_logger();
+init_errors();
+var SANITIZE_PATTERN = /[^A-Za-z0-9._-]+/g;
+var WorktreeManager = class {
+  baseDir;
+  cleanupPolicy;
+  posixMode;
+  managed = [];
+  constructor(baseDir, cleanupPolicy = "session") {
+    this.baseDir = baseDir;
+    this.cleanupPolicy = cleanupPolicy;
+    this.posixMode = false;
+  }
+  setPosixMode(enabled) {
+    this.posixMode = enabled;
+  }
+  safe(value) {
+    const cleaned = value.replace(SANITIZE_PATTERN, "-").replace(/^-+|-+$/g, "");
+    return cleaned || "default";
+  }
+  asPosix(value) {
+    let normalized = value.replace(/\\/g, "/");
+    while (normalized.startsWith("//")) {
+      normalized = normalized.slice(1);
+    }
+    return normalized;
+  }
+  commandPath(value) {
+    return this.posixMode ? this.asPosix(value) : value;
+  }
+  buildWorktreePath(assignment) {
+    const repoName = this.safe(this.asPosix(assignment.repoPath).split("/").pop() ?? "repo");
+    const branchSlug = this.safe(assignment.branch.replace(/^bnx-/, "").replace(/^origin\//, ""));
+    return `${this.baseDir}/${repoName}/${branchSlug}`;
+  }
+  async addWorktree(assignment, distribution) {
+    const target = this.buildWorktreePath(assignment);
+    logger.debug(
+      `Adding worktree pane=${assignment.pane} repo=${assignment.repoPath} branch=${assignment.branch} target=${target}`
+    );
+    const repoPath = this.commandPath(assignment.repoPath);
+    const targetPath = this.commandPath(target);
+    const pruneCmd = ["git", "-C", repoPath, "worktree", "prune"];
+    try {
+      if (distribution !== void 0 && distribution !== "") {
+        await runCommandViaWSL(distribution, pruneCmd);
+      } else {
+        await runCommand(pruneCmd);
+      }
+    } catch {
+    }
+    const existingWorktrees = await this.getWorktreesForBranch(
+      assignment.repoPath,
+      assignment.branch,
+      distribution
+    );
+    if (existingWorktrees.length > 0) {
+      const existingPath = existingWorktrees[0];
+      if (this.isUnderBaseDir(existingPath) || existingPath === repoPath) {
+        logger.info(`Reusing existing worktree at ${existingPath}`);
+        const managed = createManagedWorktree(assignment, existingPath);
+        this.managed.push(managed);
+        return managed;
+      }
+      logger.warn(`Removing stale worktree at ${existingPath}`);
+      const removeCmd = ["git", "-C", repoPath, "worktree", "remove", "--force", this.commandPath(existingPath)];
+      try {
+        if (distribution !== void 0 && distribution !== "") {
+          await runCommandViaWSL(distribution, removeCmd);
+        } else {
+          await runCommand(removeCmd);
+        }
+        logger.debug(`Removed stale worktree: ${existingPath}`);
+      } catch {
+        const pruneCmd2 = ["git", "-C", repoPath, "worktree", "prune"];
+        if (distribution !== void 0 && distribution !== "") {
+          await runCommandViaWSL(distribution, pruneCmd2);
+        } else {
+          await runCommand(pruneCmd2);
+        }
+        logger.debug("Pruned stale worktree references");
+      }
+    }
+    const cmd = ["git", "-C", repoPath, "worktree", "add", targetPath, assignment.branch];
+    try {
+      if (distribution !== void 0 && distribution !== "") {
+        await runCommandViaWSL(distribution, cmd);
+      } else {
+        await runCommand(cmd);
+      }
+      logger.debug(`Created worktree at ${target}`);
+      const managed = createManagedWorktree(assignment, target);
+      this.managed.push(managed);
+      return managed;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new BranchNexusError(
+        `Failed to create worktree for pane ${assignment.pane}`,
+        5 /* GIT_ERROR */,
+        message
+      );
+    }
+  }
+  async getCurrentBranch(repoPath, distribution) {
+    const cmd = ["git", "-C", repoPath, "branch", "--show-current"];
+    try {
+      const result = distribution !== void 0 && distribution !== "" ? await runCommandViaWSL(distribution, cmd) : await runCommand(cmd);
+      return result.stdout.trim();
+    } catch {
+      return "";
+    }
+  }
+  async materialize(assignments, distribution) {
+    logger.debug(`Materializing ${assignments.length} worktree assignments`);
+    const created = [];
+    for (const assignment of assignments.sort((a, b) => a.pane - b.pane)) {
+      created.push(await this.addWorktree(assignment, distribution));
+    }
+    return created;
+  }
+  async checkDirty(worktree, distribution) {
+    const cmd = ["git", "-C", this.commandPath(worktree.path), "status", "--porcelain"];
+    try {
+      const result = distribution !== void 0 && distribution !== "" ? await runCommandViaWSL(distribution, cmd) : await runCommand(cmd);
+      const dirty = result.stdout.trim().length > 0;
+      logger.debug(`Dirty check path=${worktree.path} dirty=${dirty}`);
+      return dirty;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new BranchNexusError(
+        `Dirty check failed for ${worktree.path}`,
+        5 /* GIT_ERROR */,
+        message
+      );
+    }
+  }
+  async cleanup(options) {
+    if (this.cleanupPolicy === "persistent" && options?.ignorePolicy !== true) {
+      logger.debug("Cleanup skipped due to persistent policy");
+      return [];
+    }
+    const targets = options?.selected ?? this.managed;
+    const removed = [];
+    const removedPaths = /* @__PURE__ */ new Set();
+    for (const worktree of targets) {
+      const worktreePath = this.commandPath(worktree.path);
+      if (removedPaths.has(worktreePath)) {
+        continue;
+      }
+      removedPaths.add(worktreePath);
+      const cmd = ["git", "-C", this.commandPath(worktree.repoPath), "worktree", "remove"];
+      if (options?.force !== false) {
+        cmd.push("--force");
+      }
+      cmd.push(worktreePath);
+      try {
+        if (options?.distribution !== void 0 && options.distribution !== "") {
+          await runCommandViaWSL(options.distribution, cmd);
+        } else {
+          await runCommand(cmd);
+        }
+        removed.push(worktreePath);
+        logger.debug(`Removed worktree at ${worktreePath}`);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new BranchNexusError(
+          `Cleanup failed for ${worktreePath}`,
+          5 /* GIT_ERROR */,
+          message
+        );
+      }
+    }
+    return removed;
+  }
+  getManaged() {
+    return [...this.managed];
+  }
+  getCleanupPolicy() {
+    return this.cleanupPolicy;
+  }
+  isUnderBaseDir(path3) {
+    const normalizedBase = this.asPosix(this.baseDir);
+    const normalizedPath = this.asPosix(path3);
+    return normalizedPath.startsWith(normalizedBase);
+  }
+  async getWorktreesForBranch(repoPath, branch, distribution) {
+    const cmd = ["git", "-C", this.commandPath(repoPath), "worktree", "list", "--porcelain"];
+    try {
+      const result = distribution !== void 0 && distribution !== "" ? await runCommandViaWSL(distribution, cmd) : await runCommand(cmd);
+      const worktrees = [];
+      let currentWorktree = "";
+      const expectedRef = branch.startsWith("refs/heads/") ? branch : `refs/heads/${branch}`;
+      for (const line of result.stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed === "") continue;
+        if (trimmed.startsWith("worktree ")) {
+          currentWorktree = trimmed.slice(9).trim();
+        } else if (trimmed.startsWith("branch ") && currentWorktree !== "") {
+          const branchRef = trimmed.slice(7).trim();
+          if (branchRef === expectedRef) {
+            worktrees.push(currentWorktree);
+          }
+        }
+      }
+      return worktrees;
+    } catch {
+      return [];
+    }
+  }
+};
+
+// ts-src/git/clone.ts
+init_esm_shims();
+init_logger();
+init_errors();
+
+// ts-src/utils/validators.ts
+init_esm_shims();
+function normalizePath(path3) {
+  return path3.replace(/\\/g, "/");
+}
+function posixPath(path3) {
+  let normalized = normalizePath(path3);
+  while (normalized.startsWith("//")) {
+    normalized = normalized.slice(1);
+  }
+  return normalized;
+}
+
+// ts-src/git/clone.ts
+async function materializeRemoteBranch(repoPath, remoteBranch, _distribution) {
+  const normalizedRepo = posixPath(repoPath);
+  if (!remoteBranch.includes("/")) {
+    throw new BranchNexusError(
+      `Invalid remote branch format: ${remoteBranch}`,
+      7 /* VALIDATION_ERROR */,
+      "Use branch names like origin/feature-x."
+    );
+  }
+  const localBranch = remoteBranch.split("/").slice(1).join("/");
+  logger.debug(
+    `Materializing remote branch repo=${normalizedRepo} remote=${remoteBranch} local=${localBranch}`
+  );
+  const git = simpleGit2(normalizedRepo);
+  try {
+    const localBranches = await git.branchLocal();
+    if (localBranches.all.includes(localBranch)) {
+      logger.debug(`Local branch already exists: ${localBranch}`);
+      return localBranch;
+    }
+  } catch {
+  }
+  try {
+    await git.branch(["--track", localBranch, remoteBranch]);
+    logger.debug(`Created tracking branch: ${localBranch}`);
+    return localBranch;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BranchNexusError(
+      `Failed to materialize remote branch ${remoteBranch}`,
+      5 /* GIT_ERROR */,
+      message
+    );
+  }
+}
+async function cloneRepository(url, targetPath) {
+  logger.debug(`Cloning repository ${url} to ${targetPath}`);
+  const git = simpleGit2();
+  try {
+    await git.clone(url, targetPath);
+    logger.debug(`Cloned repository to ${targetPath}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BranchNexusError(`Failed to clone repository: ${url}`, 5 /* GIT_ERROR */, message);
+  }
+}
+
+// ts-src/core/orchestrator.ts
+init_logger();
+async function orchestrate(request) {
+  const platform2 = detectPlatform();
+  const isWindows = platform2 === "windows" /* WINDOWS */;
+  const sessionName = request.sessionName !== void 0 && request.sessionName !== "" ? request.sessionName : "branchnexus";
+  logger.debug(
+    `Starting orchestration distribution=${request.distribution} layout=${request.layout} panes=${request.assignments.length}`
+  );
+  if (isWindows && request.distribution !== "") {
+    if (!validateDistribution(request.distribution, request.availableDistributions)) {
+      logger.error(`Invalid WSL distribution: ${request.distribution}`);
+      throw new BranchNexusError(
+        `Invalid WSL distribution: ${request.distribution}`,
+        4 /* RUNTIME_ERROR */,
+        "Re-open WSL selection and choose a discovered distribution."
+      );
+    }
+  }
+  logger.debug("Proceeding with orchestration");
+  const worktreeManager = new WorktreeManager(request.worktreeBase, request.cleanupPolicy);
+  if (isWindows) {
+    worktreeManager.setPosixMode(true);
+  }
+  const executedCommands = [];
+  const normalizedAssignments = [];
+  logger.debug("Preparing selected branches");
+  for (const assignment of request.assignments.sort((a, b) => a.pane - b.pane)) {
+    let localBranch = assignment.branch;
+    if (assignment.branch.startsWith("origin/")) {
+      logger.debug(
+        `Materializing remote branch pane=${assignment.pane} repo=${assignment.repoPath} branch=${assignment.branch}`
+      );
+      localBranch = await materializeRemoteBranch(assignment.repoPath, assignment.branch);
+    }
+    normalizedAssignments.push(
+      createWorktreeAssignment(assignment.pane, assignment.repoPath, localBranch)
+    );
+  }
+  logger.debug(`Prepared ${normalizedAssignments.length} pane assignments`);
+  let worktrees = [];
+  try {
+    logger.debug("Creating worktrees");
+    worktrees = await worktreeManager.materialize(
+      normalizedAssignments,
+      isWindows ? request.distribution : void 0
+    );
+    logger.debug(`Created ${worktrees.length} worktrees`);
+    const sorted = worktrees.sort((a, b) => a.pane - b.pane);
+    const panePaths = sorted.map((w) => w.path);
+    const paneBranches = request.displayBranches ?? sorted.map((w) => w.branch);
+    const tmuxCommands = buildLayoutCommands(
+      sessionName,
+      request.layout,
+      panePaths,
+      request.colorTheme,
+      paneBranches,
+      request.paneNames,
+      request.startupCommands
+    );
+    logger.debug("Starting tmux session");
+    await startSession(sessionName, tmuxCommands, isWindows ? request.distribution : void 0);
+    logger.debug("Orchestration finished successfully");
+    return {
+      worktrees,
+      executedCommands
+    };
+  } catch (error) {
+    if (worktrees.length > 0) {
+      try {
+        const removed = await worktreeManager.cleanup({
+          ignorePolicy: true,
+          selected: worktrees,
+          distribution: isWindows ? request.distribution : void 0
+        });
+        logger.warn(`Orchestration rollback removed ${removed.length} worktrees`);
+      } catch (cleanupError) {
+        logger.error(`Orchestration rollback cleanup failed: ${String(cleanupError)}`);
+      }
+    }
+    throw error;
+  }
+}
+
+// ts-src/prompts/wsl.ts
+init_esm_shims();
+init_errors();
+init_logger();
+async function promptWslDistribution() {
+  const platform2 = detectPlatform();
+  if (platform2 !== "windows" /* WINDOWS */) {
+    throw new BranchNexusError(
+      "WSL is only available on Windows",
+      8 /* UNSUPPORTED_PLATFORM */,
+      "Use native tmux on this platform."
+    );
+  }
+  const config = loadConfig();
+  const cachedDistribution = config.wslDistribution;
+  logger.debug("Prompting for WSL distribution");
+  const distributions = await listDistributions();
+  if (cachedDistribution && distributions.includes(cachedDistribution)) {
+    const { useCached } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "useCached",
+        message: `Use cached distribution "${cachedDistribution}"?`,
+        default: true
+      }
+    ]);
+    if (useCached) {
+      logger.debug(`Using cached distribution: ${cachedDistribution}`);
+      return cachedDistribution;
+    }
+  }
+  const { distribution } = await inquirer2.prompt([
+    {
+      type: "list",
+      name: "distribution",
+      message: "Select WSL distribution:",
+      choices: distributions.map((d) => ({ name: d, value: d }))
+    }
+  ]);
+  setWslDistribution(distribution);
+  logger.debug(`Selected distribution: ${distribution}`);
+  return distribution;
+}
+
+// ts-src/prompts/panel.ts
+init_esm_shims();
+
+// ts-src/core/presets.ts
+init_esm_shims();
+init_errors();
+function savePreset(name, preset) {
+  const validated = PresetConfigSchema.parse(preset);
+  const config = loadConfig();
+  config.presets[name] = validated;
+  saveConfig(config);
+}
+function loadPresets() {
+  const config = loadConfig();
+  return { ...config.presets };
+}
+function applyPreset(name) {
+  const presets = loadPresets();
+  const preset = presets[name];
+  if (preset === void 0) {
+    throw new BranchNexusError(
+      `Preset not found: ${name}`,
+      7 /* VALIDATION_ERROR */,
+      "Select an existing preset or create a new one."
+    );
+  }
+  return preset;
+}
+function deletePreset(name) {
+  const config = loadConfig();
+  delete config.presets[name];
+  saveConfig(config);
+}
+function renamePreset(oldName, newName) {
+  const config = loadConfig();
+  const preset = config.presets[oldName];
+  if (preset === void 0) {
+    throw new BranchNexusError(
+      `Preset not found: ${oldName}`,
+      7 /* VALIDATION_ERROR */,
+      "Choose an existing preset to rename."
+    );
+  }
+  config.presets[newName] = preset;
+  delete config.presets[oldName];
+  saveConfig(config);
+}
+function presetExists(name) {
+  const config = loadConfig();
+  return name in config.presets;
+}
+function createPresetFromCurrentConfig(name) {
+  const config = loadConfig();
+  const preset = {
+    layout: config.defaultLayout,
+    panes: config.defaultPanes,
+    cleanup: config.cleanupPolicy
+  };
+  savePreset(name, preset);
+  return preset;
+}
+
+// ts-src/utils/theme.ts
+init_esm_shims();
+var COLOR_PALETTES = {
+  cyan: {
+    name: "cyan",
+    label: "Cyan",
+    primary: chalk9.cyan,
+    primaryBold: chalk9.cyan.bold,
+    bg: chalk9.bgCyan.black.bold
+  },
+  green: {
+    name: "green",
+    label: "Ye\u015Fil",
+    primary: chalk9.green,
+    primaryBold: chalk9.green.bold,
+    bg: chalk9.bgGreen.black.bold
+  },
+  magenta: {
+    name: "magenta",
+    label: "Magenta",
+    primary: chalk9.magenta,
+    primaryBold: chalk9.magenta.bold,
+    bg: chalk9.bgMagenta.black.bold
+  },
+  blue: {
+    name: "blue",
+    label: "Mavi",
+    primary: chalk9.blue,
+    primaryBold: chalk9.blue.bold,
+    bg: chalk9.bgBlue.black.bold
+  },
+  yellow: {
+    name: "yellow",
+    label: "Sar\u0131",
+    primary: chalk9.yellow,
+    primaryBold: chalk9.yellow.bold,
+    bg: chalk9.bgYellow.black.bold
+  },
+  red: {
+    name: "red",
+    label: "K\u0131rm\u0131z\u0131",
+    primary: chalk9.red,
+    primaryBold: chalk9.red.bold,
+    bg: chalk9.bgRed.black.bold
+  }
+};
+var PALETTE_KEYS = Object.keys(COLOR_PALETTES);
+function getPalette(name) {
+  return COLOR_PALETTES[name] ?? COLOR_PALETTES.cyan;
+}
+var theme = {
+  colors: {
+    primary: chalk9.cyan,
+    success: chalk9.green,
+    warning: chalk9.yellow,
+    error: chalk9.red,
+    info: chalk9.blue,
+    muted: chalk9.gray,
+    highlight: chalk9.white.bold,
+    accent: chalk9.magenta
+  }};
+function formatPreview(key, value) {
+  return `${theme.colors.muted(key.padEnd(10))} ${theme.colors.highlight(value)}`;
+}
+
+// ts-src/prompts/github-browser.ts
+init_esm_shims();
+
+// ts-src/github/api.ts
+init_esm_shims();
+var GitHubClient = class {
+  token;
+  constructor(token) {
+    this.token = token ?? process.env.BRANCHNEXUS_GH_TOKEN ?? "";
+  }
+  async fetch(endpoint) {
+    if (this.token === "") {
+      throw new Error("GitHub token is required. Set BRANCHNEXUS_GH_TOKEN env var.");
+    }
+    const response = await fetch(`https://api.github.com${endpoint}`, {
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": "BranchNexus/1.0"
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`GitHub API error: ${response.status} ${error}`);
+    }
+    return response.json();
+  }
+  async listRepositories() {
+    const data = await this.fetch("/user/repos?per_page=100&sort=updated");
+    return data.map((repo) => ({
+      fullName: repo.full_name,
+      cloneUrl: repo.clone_url
+    }));
+  }
+  async listBranches(owner, repo) {
+    const data = await this.fetch(`/repos/${owner}/${repo}/branches?per_page=100`);
+    const defaultBranch = await this.getDefaultBranch(owner, repo);
+    return data.map((branch) => ({
+      name: branch.name,
+      isDefault: branch.name === defaultBranch
+    }));
+  }
+  async getDefaultBranch(owner, repo) {
+    const data = await this.fetch(`/repos/${owner}/${repo}`);
+    return data.default_branch ?? "main";
+  }
+};
+
+// ts-src/prompts/github-browser.ts
+var ANSI_RE = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d/#&.:=?%@~_]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+var CLR = "\x1B[K";
+function stripAnsi(str) {
+  return str.replace(ANSI_RE, "").length;
+}
+function padToWidth(content, width) {
+  const pad = Math.max(0, width - stripAnsi(content));
+  return content + " ".repeat(pad);
+}
+function boxLine(content, width) {
+  return "\u2551" + padToWidth(content, width) + "\u2551" + CLR;
+}
+function boxTop(title, width, pal) {
+  const tPad = Math.floor((width - title.length) / 2);
+  return "\u2554" + "\u2550".repeat(tPad) + pal.primaryBold(title) + "\u2550".repeat(width - tPad - title.length) + "\u2557" + CLR;
+}
+function boxMid(width) {
+  return "\u2560" + "\u2550".repeat(width) + "\u2563" + CLR;
+}
+function boxBottom(width) {
+  return "\u255A" + "\u2550".repeat(width) + "\u255D" + CLR;
+}
+var MAX_VISIBLE = 12;
+function renderBrowser(state, pal) {
+  const W = 62;
+  const lines = [];
+  lines.push(boxTop(" GitHub Repositories ", W, pal));
+  if (state.loading) {
+    lines.push(boxLine("", W));
+    lines.push(boxLine("  " + chalk9.dim("Y\xFCkleniyor..."), W));
+    lines.push(boxLine("", W));
+    lines.push(boxBottom(W));
+    return lines.join("\n");
+  }
+  if (state.error !== "") {
+    lines.push(boxLine("", W));
+    lines.push(boxLine("  " + chalk9.red(state.error), W));
+    lines.push(boxLine("", W));
+    lines.push(boxBottom(W));
+    return lines.join("\n");
+  }
+  if (state.filtering) {
+    const cursor = pal.primary(state.filterText + "\u2588");
+    lines.push(boxLine("  " + chalk9.dim("Filtre: ") + cursor, W));
+  } else if (state.filterText !== "") {
+    lines.push(boxLine("  " + chalk9.dim("Filtre: ") + chalk9.white(state.filterText), W));
+  }
+  lines.push(boxMid(W));
+  const repos = state.filteredRepos;
+  if (repos.length === 0) {
+    lines.push(boxLine("", W));
+    lines.push(boxLine("  " + chalk9.dim("E\u015Fle\u015Fen repo bulunamad\u0131"), W));
+    lines.push(boxLine("", W));
+  } else {
+    const start = state.scrollOffset;
+    const end = Math.min(start + MAX_VISIBLE, repos.length);
+    if (start > 0) {
+      lines.push(boxLine("  " + chalk9.dim(`  \u2191 ${start} daha...`), W));
+    }
+    for (let i = start; i < end; i++) {
+      const focused = i === state.selectedIndex;
+      const ptr = focused ? pal.primary("\u276F") : " ";
+      const name = repos[i].fullName;
+      const display = name.length > 50 ? "..." + name.slice(-47) : name;
+      const label = focused ? pal.primaryBold(display) : chalk9.white(display);
+      lines.push(boxLine(`  ${ptr} ${label}`, W));
+    }
+    if (end < repos.length) {
+      lines.push(boxLine("  " + chalk9.dim(`  \u2193 ${repos.length - end} daha...`), W));
+    }
+  }
+  lines.push(boxLine("", W));
+  lines.push(boxMid(W));
+  const count = chalk9.dim(`${repos.length} repo`);
+  const help = state.filtering ? "Yaz\u0131n...  Enter Onayla  Esc \u0130ptal" : "\u2191\u2193 Gezin  / Filtrele  Enter Se\xE7  Esc \xC7\u0131k\u0131\u015F";
+  lines.push(boxLine("  " + chalk9.dim(help) + "  " + count, W));
+  lines.push(boxBottom(W));
+  return lines.join("\n");
+}
+async function showGitHubBrowser(token) {
+  const config = loadConfig();
+  const pal = getPalette(config.colorTheme);
+  const state = {
+    repos: [],
+    filteredRepos: [],
+    selectedIndex: 0,
+    scrollOffset: 0,
+    filterText: "",
+    filtering: false,
+    loading: true,
+    error: ""
+  };
+  return new Promise((resolve2) => {
+    let first = true;
+    function draw() {
+      process.stdout.write(first ? "\x1B[2J\x1B[H" : "\x1B[H");
+      first = false;
+      process.stdout.write(
+        state.filtering ? "\x1B[?25h" : "\x1B[?25l"
+      );
+      process.stdout.write(renderBrowser(state, pal) + "\x1B[J\n");
+    }
+    readline.emitKeypressEvents(process.stdin);
+    const wasRaw = process.stdin.isRaw ?? false;
+    if (process.stdin.isTTY === true) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    function teardown() {
+      process.stdin.removeListener("keypress", onKey);
+      if (process.stdin.isTTY === true) {
+        process.stdin.setRawMode(wasRaw);
+      }
+      process.stdout.write("\x1B[?25h");
+      process.stdin.pause();
+    }
+    function done(result) {
+      teardown();
+      console.clear();
+      resolve2(result);
+    }
+    function applyFilter() {
+      if (state.filterText === "") {
+        state.filteredRepos = [...state.repos];
+      } else {
+        const lower = state.filterText.toLowerCase();
+        state.filteredRepos = state.repos.filter(
+          (r) => r.fullName.toLowerCase().includes(lower)
+        );
+      }
+      state.selectedIndex = 0;
+      state.scrollOffset = 0;
+    }
+    function ensureVisible() {
+      if (state.selectedIndex < state.scrollOffset) {
+        state.scrollOffset = state.selectedIndex;
+      }
+      if (state.selectedIndex >= state.scrollOffset + MAX_VISIBLE) {
+        state.scrollOffset = state.selectedIndex - MAX_VISIBLE + 1;
+      }
+    }
+    function onKey(str, key) {
+      if (key === void 0 || key === null) return;
+      if (key.ctrl === true && key.name === "c") {
+        done(null);
+        return;
+      }
+      if (state.loading) return;
+      if (state.filtering) {
+        if (key.name === "return") {
+          state.filtering = false;
+          draw();
+          return;
+        }
+        if (key.name === "escape") {
+          state.filtering = false;
+          state.filterText = "";
+          applyFilter();
+          draw();
+          return;
+        }
+        if (key.name === "backspace") {
+          state.filterText = state.filterText.slice(0, -1);
+          applyFilter();
+          draw();
+          return;
+        }
+        if (key.ctrl === true && key.name === "u") {
+          state.filterText = "";
+          applyFilter();
+          draw();
+          return;
+        }
+        if (str !== void 0 && str !== "" && key.ctrl !== true && key.meta !== true) {
+          state.filterText += str;
+          applyFilter();
+          draw();
+        }
+        return;
+      }
+      if (key.name === "escape") {
+        done(null);
+        return;
+      }
+      if (key.name === "up") {
+        if (state.selectedIndex > 0) {
+          state.selectedIndex--;
+          ensureVisible();
+        }
+        draw();
+        return;
+      }
+      if (key.name === "down") {
+        if (state.selectedIndex < state.filteredRepos.length - 1) {
+          state.selectedIndex++;
+          ensureVisible();
+        }
+        draw();
+        return;
+      }
+      if (str === "/") {
+        state.filtering = true;
+        draw();
+        return;
+      }
+      if (key.name === "return") {
+        if (state.filteredRepos.length > 0) {
+          const repo = state.filteredRepos[state.selectedIndex];
+          done({ cloneUrl: repo.cloneUrl, fullName: repo.fullName });
+        }
+        return;
+      }
+    }
+    process.stdin.on("keypress", onKey);
+    draw();
+    const client = new GitHubClient(token);
+    client.listRepositories().then((repos) => {
+      state.repos = repos;
+      state.filteredRepos = [...repos];
+      state.loading = false;
+      updateGithubRepoCache(
+        repos.map((r) => ({ full_name: r.fullName, clone_url: r.cloneUrl }))
+      );
+      draw();
+    }).catch((error) => {
+      state.loading = false;
+      state.error = error instanceof Error ? error.message : String(error);
+      draw();
+    });
+  });
+}
+
+// ts-src/prompts/panel.ts
+var LAYOUTS = [
+  { value: "grid", label: "Grid (2x2)" },
+  { value: "horizontal", label: "Yatay" },
+  { value: "vertical", label: "Dikey" }
+];
+var PANE_OPTIONS = [1, 2, 3, 4, 5, 6];
+var CLEANUP_OPTIONS = [
+  { value: "session", label: "Session" },
+  { value: "persistent", label: "Persistent" }
+];
+var FIELD = {
+  HAS_TOKEN: 0,
+  TOKEN: 1,
+  REPO: 2,
+  LAYOUT: 3,
+  PANES: 4,
+  CLEANUP: 5,
+  COLOR: 6,
+  SUBMIT: 7
+};
+var COLOR_OPTIONS = PALETTE_KEYS.map((key) => ({
+  value: key,
+  label: COLOR_PALETTES[key].label
+}));
+var ANSI_RE2 = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d/#&.:=?%@~_]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+var CLR2 = "\x1B[K";
+function stripAnsi2(str) {
+  return str.replace(ANSI_RE2, "");
+}
+function visibleLength(str) {
+  return stripAnsi2(str).length;
+}
+function padToWidth2(content, width) {
+  const pad = Math.max(0, width - visibleLength(content));
+  return content + " ".repeat(pad);
+}
+function boxLine2(content, width) {
+  return "\u2551" + padToWidth2(content, width) + "\u2551" + CLR2;
+}
+function boxTop2(title, width, pal) {
+  const tPad = Math.floor((width - title.length) / 2);
+  return "\u2554" + "\u2550".repeat(tPad) + pal.primaryBold(title) + "\u2550".repeat(width - tPad - title.length) + "\u2557" + CLR2;
+}
+function boxMid2(width) {
+  return "\u2560" + "\u2550".repeat(width) + "\u2563" + CLR2;
+}
+function boxBottom2(width) {
+  return "\u255A" + "\u2550".repeat(width) + "\u255D" + CLR2;
+}
+function selectDisplay(label, focused, pal) {
+  if (focused) {
+    return chalk9.dim("\u25C0 ") + pal.primaryBold(label) + chalk9.dim(" \u25B6");
+  }
+  return chalk9.white(label);
+}
+function renderButton(label, focused, width, pal) {
+  const btn = focused ? pal.bg(` \u25B6 ${label} `) : chalk9.dim(` \u25B6 ${label} `);
+  const btnLen = visibleLength(btn);
+  const left = Math.floor((width - btnLen) / 2);
+  const right = Math.max(0, width - left - btnLen);
+  return "\u2551" + " ".repeat(left) + btn + " ".repeat(right) + "\u2551" + CLR2;
+}
+function attachKeypress(handler) {
+  readline.emitKeypressEvents(process.stdin);
+  const wasRaw = process.stdin.isRaw ?? false;
+  if (process.stdin.isTTY === true) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  function onKey(str, key) {
+    if (key === void 0 || key === null) return;
+    if (key.ctrl === true && key.name === "c") {
+      teardown();
+      process.exit(0);
+    }
+    handler(str, key);
+  }
+  function teardown() {
+    process.stdin.removeListener("keypress", onKey);
+    if (process.stdin.isTTY === true) {
+      process.stdin.setRawMode(wasRaw);
+    }
+    process.stdout.write("\x1B[?25h");
+    process.stdin.pause();
+  }
+  process.stdin.on("keypress", onKey);
+  return { teardown };
+}
+function createDrawFn(renderFn) {
+  let first = true;
+  return (editing) => {
+    process.stdout.write(first ? "\x1B[2J\x1B[H" : "\x1B[H");
+    first = false;
+    process.stdout.write(editing ? "\x1B[?25h" : "\x1B[?25l");
+    process.stdout.write(renderFn() + "\x1B[J\n");
+  };
+}
+function getPanelNav(state) {
+  const fields = [FIELD.HAS_TOKEN];
+  if (state.hasToken) {
+    fields.push(FIELD.TOKEN);
+  }
+  fields.push(FIELD.REPO, FIELD.LAYOUT, FIELD.PANES, FIELD.CLEANUP, FIELD.COLOR, FIELD.SUBMIT);
+  return fields;
+}
+function renderPanel(state) {
+  const W = 58;
+  const LBL_W = 17;
+  const lines = [];
+  const pal = getPalette(COLOR_OPTIONS[state.colorIndex].value);
+  function fRow(id, label, value) {
+    const focused = state.focusIndex === id;
+    const ptr = focused ? pal.primary("\u276F") : " ";
+    const lbl = focused ? pal.primaryBold(label.padEnd(LBL_W)) : chalk9.white(label.padEnd(LBL_W));
+    return boxLine2(`  ${ptr} ${lbl} ${value}`, W);
+  }
+  lines.push(boxTop2(" BranchNexus ", W, pal));
+  lines.push(boxLine2("  " + chalk9.dim("Multi-Branch Workspace Manager"), W));
+  lines.push(boxMid2(W));
+  lines.push(boxLine2("", W));
+  const tokLabel = state.hasToken ? "Evet" : "Hay\u0131r";
+  lines.push(fRow(FIELD.HAS_TOKEN, "GitHub Token", selectDisplay(tokLabel, state.focusIndex === FIELD.HAS_TOKEN, pal)));
+  if (state.hasToken) {
+    let tv;
+    if (state.focusIndex === FIELD.TOKEN && state.editing) {
+      tv = pal.primary(state.editBuffer + "\u2588");
+    } else if (state.token !== "") {
+      tv = chalk9.dim("*".repeat(Math.min(state.token.length, 20)));
+    } else {
+      tv = chalk9.dim("(Enter ile girin)");
+    }
+    lines.push(fRow(FIELD.TOKEN, "  Token", tv));
+  }
+  let rv;
+  if (state.focusIndex === FIELD.REPO && state.editing) {
+    const buf = state.editBuffer;
+    rv = pal.primary((buf.length > 28 ? "..." + buf.slice(-25) : buf) + "\u2588");
+  } else if (state.repoUrl !== "") {
+    const s = state.repoUrl;
+    rv = chalk9.white(s.length > 30 ? s.slice(0, 27) + "..." : s);
+  } else {
+    rv = chalk9.dim("(Enter ile girin)");
+  }
+  lines.push(fRow(FIELD.REPO, "Repository URL", rv));
+  lines.push(fRow(FIELD.LAYOUT, "Layout", selectDisplay(LAYOUTS[state.layoutIndex].label, state.focusIndex === FIELD.LAYOUT, pal)));
+  lines.push(fRow(FIELD.PANES, "Pane Say\u0131s\u0131", selectDisplay(String(PANE_OPTIONS[state.panesIndex]), state.focusIndex === FIELD.PANES, pal)));
+  lines.push(fRow(FIELD.CLEANUP, "Cleanup", selectDisplay(CLEANUP_OPTIONS[state.cleanupIndex].label, state.focusIndex === FIELD.CLEANUP, pal)));
+  const colorLabel = COLOR_OPTIONS[state.colorIndex].label;
+  const colorPreview = pal.primary("\u25A0 ") + colorLabel;
+  lines.push(fRow(FIELD.COLOR, "Renk", selectDisplay(colorPreview, state.focusIndex === FIELD.COLOR, pal)));
+  lines.push(boxLine2("", W));
+  if (state.error !== "") {
+    lines.push(boxLine2("  " + chalk9.red("\u26A0 " + state.error), W));
+    lines.push(boxLine2("", W));
+  }
+  lines.push(renderButton("BA\u015ELAT", state.focusIndex === FIELD.SUBMIT, W, pal));
+  lines.push(boxLine2("", W));
+  lines.push(boxMid2(W));
+  const help = state.editing ? "Yaz\u0131n...  Enter Onayla  Esc \u0130ptal  Ctrl+U Temizle" : "\u2191\u2193 Gezin  \u2190\u2192 De\u011Fi\u015Ftir  Enter D\xFCzenle  P Preset  G GitHub  Esc \xC7\u0131k\u0131\u015F";
+  lines.push(boxLine2("  " + chalk9.dim(help), W));
+  lines.push(boxBottom2(W));
+  return lines.join("\n");
+}
+async function showPanel() {
+  const config = loadConfig();
+  let layoutIdx = LAYOUTS.findIndex((l) => l.value === config.defaultLayout);
+  if (layoutIdx < 0) layoutIdx = 0;
+  let panesIdx = PANE_OPTIONS.indexOf(config.defaultPanes > 0 ? config.defaultPanes : 4);
+  if (panesIdx < 0) panesIdx = 3;
+  let cleanupIdx = CLEANUP_OPTIONS.findIndex((o) => o.value === config.cleanupPolicy);
+  if (cleanupIdx < 0) cleanupIdx = 0;
+  let colorIdx = PALETTE_KEYS.indexOf(config.colorTheme);
+  if (colorIdx < 0) colorIdx = 0;
+  const state = {
+    focusIndex: FIELD.REPO,
+    editing: false,
+    editBuffer: "",
+    error: "",
+    hasToken: config.githubToken !== void 0 && config.githubToken !== "",
+    token: "",
+    repoUrl: "",
+    layoutIndex: layoutIdx,
+    panesIndex: panesIdx,
+    cleanupIndex: cleanupIdx,
+    colorIndex: colorIdx
+  };
+  return new Promise((resolve2) => {
+    const draw = createDrawFn(() => renderPanel(state));
+    const { teardown } = attachKeypress((str, key) => {
+      state.error = "";
+      if (state.editing) {
+        panelEdit(str, key);
+      } else {
+        panelNav(str, key);
+      }
+    });
+    function done(result) {
+      teardown();
+      console.clear();
+      resolve2(result);
+    }
+    function panelEdit(str, key) {
+      if (key.name === "return") {
+        if (state.focusIndex === FIELD.TOKEN) state.token = state.editBuffer;
+        else if (state.focusIndex === FIELD.REPO) state.repoUrl = state.editBuffer;
+        state.editing = false;
+        draw(false);
+        return;
+      }
+      if (key.name === "escape") {
+        state.editing = false;
+        draw(false);
+        return;
+      }
+      if (key.name === "backspace") {
+        state.editBuffer = state.editBuffer.slice(0, -1);
+        draw(true);
+        return;
+      }
+      if (key.ctrl === true && key.name === "u") {
+        state.editBuffer = "";
+        draw(true);
+        return;
+      }
+      if (str !== void 0 && str !== "" && key.ctrl !== true && key.meta !== true) {
+        state.editBuffer += str;
+        draw(true);
+      }
+    }
+    function panelNav(str, key) {
+      const nav = getPanelNav(state);
+      const idx = nav.indexOf(state.focusIndex);
+      if (key.name === "escape") {
+        done(null);
+        return;
+      }
+      if (key.name === "up" || key.name === "tab" && key.shift === true) {
+        if (idx > 0) state.focusIndex = nav[idx - 1];
+        draw(false);
+        return;
+      }
+      if (key.name === "down" || key.name === "tab") {
+        if (idx < nav.length - 1) state.focusIndex = nav[idx + 1];
+        draw(false);
+        return;
+      }
+      if (key.name === "left" || key.name === "right") {
+        const d = key.name === "right" ? 1 : -1;
+        panelCycle(d);
+        draw(false);
+        return;
+      }
+      if (key.name === "space") {
+        panelCycle(1);
+        draw(false);
+        return;
+      }
+      if (str === "p" || str === "P") {
+        const presets = loadPresets();
+        const names = Object.keys(presets);
+        if (names.length === 0) {
+          state.error = "Kay\u0131tl\u0131 preset yok";
+          draw(false);
+          return;
+        }
+        const currentConfig = `${LAYOUTS[state.layoutIndex].value}-${PANE_OPTIONS[state.panesIndex]}-${CLEANUP_OPTIONS[state.cleanupIndex].value}`;
+        let nextIdx = 0;
+        for (let i = 0; i < names.length; i++) {
+          const pr = presets[names[i]];
+          const key2 = `${pr.layout}-${pr.panes}-${pr.cleanup}`;
+          if (key2 === currentConfig && i < names.length - 1) {
+            nextIdx = i + 1;
+            break;
+          }
+        }
+        const preset = applyPreset(names[nextIdx]);
+        const li = LAYOUTS.findIndex((l) => l.value === preset.layout);
+        if (li >= 0) state.layoutIndex = li;
+        const pi = PANE_OPTIONS.indexOf(preset.panes);
+        if (pi >= 0) state.panesIndex = pi;
+        const ci = CLEANUP_OPTIONS.findIndex((o) => o.value === preset.cleanup);
+        if (ci >= 0) state.cleanupIndex = ci;
+        state.error = `Preset: ${names[nextIdx]}`;
+        draw(false);
+        return;
+      }
+      if (str === "g" || str === "G") {
+        const token = state.hasToken && state.token !== "" ? state.token : loadConfig().githubToken;
+        if (token === "") {
+          state.error = "GitHub token gerekli";
+          draw(false);
+          return;
+        }
+        teardown();
+        showGitHubBrowser(token).then((result) => {
+          if (result !== null) {
+            state.repoUrl = result.cloneUrl;
+          }
+          const reattached = attachKeypress((s, k) => {
+            state.error = "";
+            if (state.editing) {
+              panelEdit(s, k);
+            } else {
+              panelNav(s, k);
+            }
+          });
+          Object.assign({ teardown: reattached.teardown });
+          draw(false);
+        }).catch(() => {
+          draw(false);
+        });
+        return;
+      }
+      if (key.name === "return") {
+        panelEnter();
+        return;
+      }
+    }
+    function panelCycle(d) {
+      switch (state.focusIndex) {
+        case FIELD.HAS_TOKEN:
+          state.hasToken = !state.hasToken;
+          break;
+        case FIELD.LAYOUT:
+          state.layoutIndex = (state.layoutIndex + d + LAYOUTS.length) % LAYOUTS.length;
+          break;
+        case FIELD.PANES:
+          state.panesIndex = (state.panesIndex + d + PANE_OPTIONS.length) % PANE_OPTIONS.length;
+          break;
+        case FIELD.CLEANUP:
+          state.cleanupIndex = (state.cleanupIndex + d + CLEANUP_OPTIONS.length) % CLEANUP_OPTIONS.length;
+          break;
+        case FIELD.COLOR:
+          state.colorIndex = (state.colorIndex + d + COLOR_OPTIONS.length) % COLOR_OPTIONS.length;
+          break;
+      }
+    }
+    function panelEnter() {
+      if (state.focusIndex === FIELD.TOKEN || state.focusIndex === FIELD.REPO) {
+        state.editing = true;
+        state.editBuffer = state.focusIndex === FIELD.TOKEN ? state.token : state.repoUrl;
+        draw(true);
+        return;
+      }
+      if (state.focusIndex === FIELD.HAS_TOKEN) {
+        state.hasToken = !state.hasToken;
+        draw(false);
+        return;
+      }
+      if (state.focusIndex === FIELD.SUBMIT) {
+        if (state.repoUrl.trim() === "") {
+          state.error = "Repository URL gerekli";
+          state.focusIndex = FIELD.REPO;
+          draw(false);
+          return;
+        }
+        const url = state.repoUrl.trim();
+        if (!url.includes("github.com") && !url.includes("gitlab.com") && !url.includes("bitbucket.org")) {
+          state.error = "Ge\xE7erli bir Git URL girin";
+          state.focusIndex = FIELD.REPO;
+          draw(false);
+          return;
+        }
+        if (state.hasToken && state.token !== "") {
+          setGithubToken(state.token);
+        }
+        const selectedColor = COLOR_OPTIONS[state.colorIndex].value;
+        const cfg = loadConfig();
+        cfg.colorTheme = selectedColor;
+        saveConfig(cfg);
+        const urls = url.split(",").map((u) => u.trim()).filter((u) => u !== "");
+        done({
+          token: state.hasToken && state.token !== "" ? state.token : null,
+          repoUrl: urls[0],
+          repoUrls: urls,
+          layout: LAYOUTS[state.layoutIndex].value,
+          paneCount: PANE_OPTIONS[state.panesIndex],
+          cleanup: CLEANUP_OPTIONS[state.cleanupIndex].value,
+          colorTheme: selectedColor
+        });
+        return;
+      }
+      draw(false);
+    }
+    draw(false);
+  });
+}
+var RANDOM_NAMES = [
+  "Alpha",
+  "Beta",
+  "Gamma",
+  "Delta",
+  "Epsilon",
+  "Zeta",
+  "Nova",
+  "Orion",
+  "Vega",
+  "Atlas",
+  "Comet",
+  "Pulsar",
+  "Spark",
+  "Blaze",
+  "Storm",
+  "Frost",
+  "Lunar",
+  "Solar"
+];
+function pickRandomNames(count) {
+  const shuffled = [...RANDOM_NAMES].sort(() => Math.random() - 0.5);
+  return shuffled.slice(0, count);
+}
+function renderBranchForm(state, branches, paneCount, pal) {
+  const W = 62;
+  const lines = [];
+  const submitIdx = paneCount;
+  lines.push(boxTop2(" Branch Se\xE7imi ", W, pal));
+  lines.push(boxLine2("  " + chalk9.dim("\u2190\u2192 Branch  N \u0130sim  C Komut"), W));
+  lines.push(boxMid2(W));
+  lines.push(boxLine2("", W));
+  const usageCount = /* @__PURE__ */ new Map();
+  for (const bi of state.branchIndices) {
+    usageCount.set(bi, (usageCount.get(bi) ?? 0) + 1);
+  }
+  for (let i = 0; i < paneCount; i++) {
+    const focused = state.focusIndex === i;
+    const ptr = focused ? pal.primary("\u276F") : " ";
+    if (focused && state.editing) {
+      const editLabel = pal.primaryBold("\u0130sim: ");
+      const cursor = pal.primary(state.editBuffer + "\u2588");
+      lines.push(boxLine2(`  ${ptr} ${editLabel}${cursor}`, W));
+      continue;
+    }
+    if (focused && state.editingCommand) {
+      const editLabel = pal.primaryBold("Cmd:  ");
+      const cursor = pal.primary(state.editBuffer + "\u2588");
+      lines.push(boxLine2(`  ${ptr} ${editLabel}${cursor}`, W));
+      continue;
+    }
+    const name = state.paneNames[i];
+    const nameDisplay = focused ? pal.primaryBold(name.padEnd(10)) : chalk9.white(name.padEnd(10));
+    const branchName = branches[state.branchIndices[i]];
+    const shortBranch = branchName.length > 22 ? "..." + branchName.slice(-19) : branchName;
+    const isDuplicate = (usageCount.get(state.branchIndices[i]) ?? 0) > 1;
+    const dupHint = isDuplicate ? chalk9.yellow(" +fork") : "";
+    const cmdHint = state.startupCommands[i] !== "" ? chalk9.dim(" $") : "";
+    const branchDisplay = selectDisplay(shortBranch, focused, pal) + dupHint + cmdHint;
+    lines.push(boxLine2(`  ${ptr} ${nameDisplay} ${chalk9.dim("\u2502")} ${branchDisplay}`, W));
+  }
+  lines.push(boxLine2("", W));
+  if (state.error !== "") {
+    lines.push(boxLine2("  " + chalk9.red("\u26A0 " + state.error), W));
+    lines.push(boxLine2("", W));
+  }
+  lines.push(renderButton("ONAYLA", state.focusIndex === submitIdx, W, pal));
+  lines.push(boxLine2("", W));
+  lines.push(boxMid2(W));
+  const help = state.editing || state.editingCommand ? "Yaz\u0131n...  Enter Onayla  Esc \u0130ptal  Ctrl+U Temizle" : "\u2191\u2193 Gezin  \u2190\u2192 Branch  N \u0130sim  C Komut  Enter Onayla  Esc \xC7\u0131k\u0131\u015F";
+  lines.push(boxLine2("  " + chalk9.dim(help), W));
+  lines.push(boxBottom2(W));
+  return lines.join("\n");
+}
+async function showBranchSelection(availableBranches, paneCount) {
+  const submitIdx = paneCount;
+  const initialIndices = [];
+  for (let i = 0; i < paneCount; i++) {
+    initialIndices.push(i % availableBranches.length);
+  }
+  const randomNames = pickRandomNames(paneCount);
+  const state = {
+    focusIndex: 0,
+    branchIndices: initialIndices,
+    paneNames: randomNames,
+    startupCommands: Array.from({ length: paneCount }, () => ""),
+    editing: false,
+    editingCommand: false,
+    editBuffer: "",
+    error: ""
+  };
+  const pal = getPalette(loadConfig().colorTheme);
+  return new Promise((resolve2) => {
+    const draw = createDrawFn(() => renderBranchForm(state, availableBranches, paneCount, pal));
+    const { teardown } = attachKeypress((str, key) => {
+      state.error = "";
+      if (state.editing) {
+        if (key.name === "return") {
+          const val = state.editBuffer.trim();
+          state.paneNames[state.focusIndex] = val !== "" ? val : randomNames[state.focusIndex];
+          state.editing = false;
+          draw(false);
+          return;
+        }
+        if (key.name === "escape") {
+          state.editing = false;
+          draw(false);
+          return;
+        }
+        if (key.name === "backspace") {
+          state.editBuffer = state.editBuffer.slice(0, -1);
+          draw(true);
+          return;
+        }
+        if (key.ctrl === true && key.name === "u") {
+          state.editBuffer = "";
+          draw(true);
+          return;
+        }
+        if (str !== void 0 && str !== "" && key.ctrl !== true && key.meta !== true) {
+          state.editBuffer += str;
+          draw(true);
+        }
+        return;
+      }
+      if (state.editingCommand) {
+        if (key.name === "return") {
+          state.startupCommands[state.focusIndex] = state.editBuffer.trim();
+          state.editingCommand = false;
+          draw(false);
+          return;
+        }
+        if (key.name === "escape") {
+          state.editingCommand = false;
+          draw(false);
+          return;
+        }
+        if (key.name === "backspace") {
+          state.editBuffer = state.editBuffer.slice(0, -1);
+          draw(true);
+          return;
+        }
+        if (key.ctrl === true && key.name === "u") {
+          state.editBuffer = "";
+          draw(true);
+          return;
+        }
+        if (str !== void 0 && str !== "" && key.ctrl !== true && key.meta !== true) {
+          state.editBuffer += str;
+          draw(true);
+        }
+        return;
+      }
+      if (key.name === "escape") {
+        teardown();
+        console.clear();
+        resolve2(null);
+        return;
+      }
+      if (key.name === "up" || key.name === "tab" && key.shift === true) {
+        if (state.focusIndex > 0) state.focusIndex--;
+        draw(false);
+        return;
+      }
+      if (key.name === "down" || key.name === "tab") {
+        if (state.focusIndex < submitIdx) state.focusIndex++;
+        draw(false);
+        return;
+      }
+      if ((str === "n" || str === "N") && state.focusIndex < paneCount) {
+        state.editing = true;
+        state.editBuffer = state.paneNames[state.focusIndex];
+        draw(true);
+        return;
+      }
+      if ((str === "c" || str === "C") && state.focusIndex < paneCount) {
+        state.editingCommand = true;
+        state.editBuffer = state.startupCommands[state.focusIndex];
+        draw(true);
+        return;
+      }
+      if (key.name === "left" || key.name === "right") {
+        if (state.focusIndex < paneCount) {
+          const d = key.name === "right" ? 1 : -1;
+          const cur = state.branchIndices[state.focusIndex];
+          state.branchIndices[state.focusIndex] = (cur + d + availableBranches.length) % availableBranches.length;
+        }
+        draw(false);
+        return;
+      }
+      if (key.name === "space" && state.focusIndex < paneCount) {
+        const cur = state.branchIndices[state.focusIndex];
+        state.branchIndices[state.focusIndex] = (cur + 1) % availableBranches.length;
+        draw(false);
+        return;
+      }
+      if (key.name === "return") {
+        if (state.focusIndex === submitIdx) {
+          const selected = state.branchIndices.map((bi) => availableBranches[bi]);
+          teardown();
+          console.clear();
+          resolve2({
+            branches: selected,
+            paneNames: [...state.paneNames],
+            startupCommands: [...state.startupCommands]
+          });
+          return;
+        }
+        if (state.focusIndex < paneCount) {
+          const cur = state.branchIndices[state.focusIndex];
+          state.branchIndices[state.focusIndex] = (cur + 1) % availableBranches.length;
+          draw(false);
+        }
+      }
+    });
+    draw(false);
+  });
+}
+function showPreview(data) {
+  console.log();
+  console.log(chalk9.dim("\u2500".repeat(50)));
+  console.log(chalk9.bold("\u{1F4CB} \xD6N\u0130ZLEME"));
+  console.log(chalk9.dim("\u2500".repeat(50)));
+  console.log();
+  console.log(formatPreview("Repo", data.repoUrl));
+  console.log(formatPreview("Layout", data.layout.toUpperCase()));
+  console.log(formatPreview("Branches", `${data.branchCount} adet`));
+  data.branches.forEach((b, i) => {
+    console.log(chalk9.dim(`   ${i + 1}. ${b}`));
+  });
+  console.log(formatPreview("Cleanup", data.cleanup === "session" ? "Session" : "Persistent"));
+  console.log();
+}
+async function confirmStart() {
+  const confirm3 = await p3.confirm({
+    message: "Ba\u015Flatmak i\xE7in onayla",
+    initialValue: true
+  });
+  return confirm3 === true;
+}
+function showSuccess(message) {
+  p3.outro(chalk9.green("\u2713 ") + message);
+}
+function showError(message, hint) {
+  console.log();
+  console.log(chalk9.red("\u2715 ") + message);
+  if (hint !== void 0 && hint !== "") {
+    console.log(chalk9.dim("  \u2192 " + hint));
+  }
+}
+
+// ts-src/prompts/cleanup.ts
+init_esm_shims();
+async function promptCleanup(dirtyPaths) {
+  console.log();
+  console.log(chalk9.yellow("\u26A0 Kaydedilmemi\u015F de\u011Fi\u015Fiklikler tespit edildi:"));
+  console.log();
+  for (const path3 of dirtyPaths) {
+    const short = path3.split("/").slice(-2).join("/");
+    console.log(chalk9.dim(`  \u25CF ${short}`));
+  }
+  console.log();
+  const choice = await p3.select({
+    message: "Ne yapmak istersiniz?",
+    options: [
+      {
+        value: "Koruyarak Cik" /* PRESERVE */,
+        label: "Koruyarak \xC7\u0131k",
+        hint: "Dirty worktree'ler korunur, temizler silinir"
+      },
+      {
+        value: "Temizleyerek Cik" /* CLEAN */,
+        label: "Temizleyerek \xC7\u0131k",
+        hint: "T\xFCm worktree'ler silinir (de\u011Fi\u015Fiklikler kaybolur!)"
+      },
+      {
+        value: "Vazgec" /* CANCEL */,
+        label: "Vazge\xE7",
+        hint: "Hi\xE7bir \u015Fey yapma"
+      }
+    ]
+  });
+  if (p3.isCancel(choice)) {
+    return "Vazgec" /* CANCEL */;
+  }
+  return choice;
+}
+
+// ts-src/commands/run.ts
+init_logger();
+
+// ts-src/hooks/runner.ts
+init_esm_shims();
+init_logger();
+var HookRunner = class {
+  timeoutSeconds;
+  trustedConfig;
+  allowCommandPrefixes;
+  constructor(options) {
+    this.timeoutSeconds = options?.timeoutSeconds ?? 30;
+    this.trustedConfig = options?.trustedConfig ?? true;
+    this.allowCommandPrefixes = options?.allowCommandPrefixes ?? [];
+  }
+  isCommandAllowed(command) {
+    if (this.trustedConfig) {
+      return true;
+    }
+    const argv = command.split(/\s+/);
+    if (argv.length === 0) {
+      return false;
+    }
+    if (this.allowCommandPrefixes.length === 0) {
+      return false;
+    }
+    return this.allowCommandPrefixes.includes(argv[0]);
+  }
+  async run(pane, commands, distribution) {
+    const executions = [];
+    logger.debug(`Running ${commands.length} hook commands for pane=${pane}`);
+    for (const command of commands) {
+      if (!this.isCommandAllowed(command)) {
+        logger.warn(`Hook command blocked by policy pane=${pane} command=${command}`);
+        executions.push({
+          command,
+          success: false,
+          returncode: 126,
+          output: "Command blocked by hook trust policy."
+        });
+        continue;
+      }
+      try {
+        logger.debug(`Executing hook command pane=${pane} command=${command}`);
+        const isWindows = detectPlatform() === "windows" /* WINDOWS */;
+        const cmd = ["bash", "-lc", command];
+        const finalCmd = isWindows && distribution !== void 0 && distribution !== "" ? buildWslCommand(distribution, cmd) : cmd;
+        const result = await execa(finalCmd[0], finalCmd.slice(1), {
+          timeout: this.timeoutSeconds * 1e3,
+          reject: false,
+          all: true
+        });
+        const success = result.exitCode === 0;
+        const output = `${result.stdout}${result.stderr}`.trim();
+        if (!success) {
+          logger.warn(
+            `Hook command failed pane=${pane} returncode=${result.exitCode} command=${command}`
+          );
+        }
+        executions.push({
+          command,
+          success,
+          returncode: result.exitCode,
+          output
+        });
+      } catch (error) {
+        const isTimeout = error instanceof Error && error.message.includes("timed out");
+        logger.error(
+          `Hook command ${isTimeout ? "timed out" : "failed"} pane=${pane} command=${command}`
+        );
+        executions.push({
+          command,
+          success: false,
+          returncode: isTimeout ? 124 : 1,
+          output: isTimeout ? "Command timed out." : error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    }
+    return {
+      pane,
+      executions,
+      hasFailures: executions.some((e) => !e.success)
+    };
+  }
+};
+
+// ts-src/core/session.ts
+init_esm_shims();
+init_logger();
+var TERMINAL_MIN = 2;
+var TERMINAL_MAX = 16;
+function validateTerminalCount(value) {
+  if (value < TERMINAL_MIN || value > TERMINAL_MAX) {
+    throw new Error(`Invalid terminal count: ${value}`);
+  }
+  return value;
+}
+function parseRuntimeSnapshot(raw) {
+  if (!isSessionSnapshot(raw)) {
+    return null;
+  }
+  const snapshot = raw;
+  if (snapshot.terminals.length === 0) {
+    return null;
+  }
+  try {
+    validateTerminalCount(snapshot.templateCount);
+  } catch {
+    return null;
+  }
+  const terminals = [];
+  for (const item of snapshot.terminals) {
+    if (!item.terminalId) {
+      return null;
+    }
+    const runtime = normalizeRuntimeKind(item.runtime);
+    if (!runtime) {
+      return null;
+    }
+    terminals.push({
+      terminalId: item.terminalId.trim(),
+      title: item.title?.trim() || item.terminalId,
+      runtime,
+      repoPath: item.repoPath?.trim() || "",
+      branch: item.branch?.trim() || ""
+    });
+  }
+  return {
+    layout: snapshot.layout || "grid",
+    templateCount: snapshot.templateCount,
+    focusedTerminalId: snapshot.focusedTerminalId?.trim() || "",
+    terminals
+  };
+}
+function normalizeRuntimeKind(value) {
+  const normalized = value?.toLowerCase().trim();
+  if (normalized === "wsl") return "wsl";
+  if (normalized === "powershell") return "powershell";
+  if (normalized === "native") return "native";
+  return null;
+}
+var SessionCleanupHandler = class {
+  manager;
+  prompt;
+  distribution;
+  constructor(manager, prompt, distribution) {
+    this.manager = manager;
+    this.prompt = prompt;
+    this.distribution = distribution;
+  }
+  async handleExit() {
+    if (this.manager.getCleanupPolicy() === "persistent") {
+      logger.debug("Session cleanup skipped due to persistent policy");
+      return {
+        closed: true,
+        cancelled: false,
+        removed: [],
+        preservedDirty: this.manager.getManaged().map((w) => w.path)
+      };
+    }
+    const dirty = [];
+    const clean = [];
+    for (const worktree of this.manager.getManaged()) {
+      const isDirty = await this.manager.checkDirty(worktree, this.distribution);
+      if (isDirty) {
+        dirty.push(worktree);
+      } else {
+        clean.push(worktree);
+      }
+    }
+    logger.debug(`Cleanup check complete dirty=${dirty.length} clean=${clean.length}`);
+    if (dirty.length === 0) {
+      const removed = await this.manager.cleanup({
+        distribution: this.distribution
+      });
+      logger.debug(`All worktrees clean; removed=${removed.length}`);
+      return {
+        closed: true,
+        cancelled: false,
+        removed,
+        preservedDirty: []
+      };
+    }
+    const choice = await this.prompt(dirty.map((w) => w.path));
+    logger.info(`Cleanup prompt result choice=${choice} dirty_count=${dirty.length}`);
+    if (choice === "Vazgec" /* CANCEL */) {
+      return {
+        closed: false,
+        cancelled: true,
+        removed: [],
+        preservedDirty: dirty.map((w) => w.path)
+      };
+    }
+    if (choice === "Koruyarak Cik" /* PRESERVE */) {
+      const removedClean = await this.manager.cleanup({
+        selected: clean,
+        distribution: this.distribution
+      });
+      logger.debug(`Preserve dirty worktrees; removed clean=${removedClean.length}`);
+      return {
+        closed: true,
+        cancelled: false,
+        removed: removedClean,
+        preservedDirty: dirty.map((w) => w.path)
+      };
+    }
+    const removedAll = await this.manager.cleanup({
+      distribution: this.distribution
+    });
+    logger.debug(`Cleanup forced for all worktrees removed=${removedAll.length}`);
+    return {
+      closed: true,
+      cancelled: false,
+      removed: removedAll,
+      preservedDirty: []
+    };
+  }
+};
+
+// ts-src/commands/run.ts
+async function ensureTmuxInstalled() {
+  const tmuxInstalled = await hasTmux();
+  if (tmuxInstalled) {
+    return;
+  }
+  const platform2 = detectPlatform();
+  console.log(chalk9.yellow("\n\u{1F4E6} tmux bulunamad\u0131, kuruluyor...\n"));
+  if (platform2 === "macos" /* MACOS */) {
+    try {
+      await execa("brew", ["install", "tmux"], { timeout: 12e4 });
+      console.log(chalk9.green("\u2705 tmux kuruldu!\n"));
+      return;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      throw new BranchNexusError(
+        `tmux kurulumu ba\u015Far\u0131s\u0131z: ${msg}`,
+        6 /* TMUX_ERROR */,
+        "Manuel kurulum: brew install tmux"
+      );
+    }
+  }
+  let installCmd;
+  try {
+    await execa("bash", ["-lc", "which apt-get"]);
+    installCmd = "apt-get update && apt-get install -y tmux";
+  } catch {
+    try {
+      await execa("bash", ["-lc", "which dnf"]);
+      installCmd = "dnf install -y tmux";
+    } catch {
+      try {
+        await execa("bash", ["-lc", "which pacman"]);
+        installCmd = "pacman -S --noconfirm tmux";
+      } catch {
+        try {
+          await execa("bash", ["-lc", "which apk"]);
+          installCmd = "apk add tmux";
+        } catch {
+          throw new BranchNexusError(
+            "Paket y\xF6neticisi bulunamad\u0131.",
+            6 /* TMUX_ERROR */,
+            "L\xFCtfen tmux'u manuel kurun."
+          );
+        }
+      }
+    }
+  }
+  try {
+    console.log(chalk9.dim(`\xC7al\u0131\u015Ft\u0131r\u0131l\u0131yor: sudo ${installCmd}`));
+    await execa("sudo", ["-n", "bash", "-lc", installCmd], { timeout: 18e4 });
+    console.log(chalk9.green("\u2705 tmux kuruldu!\n"));
+    return;
+  } catch {
+  }
+  console.log(chalk9.cyan("Ba\u015Fka bir terminalde bu komutu \xE7al\u0131\u015Ft\u0131r\u0131n:\n"));
+  console.log(chalk9.bold.white(`  sudo ${installCmd}
+`));
+  console.log(chalk9.dim("tmux kurulumu bekleniyor..."));
+  for (let i = 0; i < 60; i++) {
+    await new Promise((r) => setTimeout(r, 2e3));
+    const installed = await hasTmux();
+    if (installed) {
+      console.log(chalk9.green("\n\u2705 tmux alg\u0131land\u0131!\n"));
+      return;
+    }
+    process.stdout.write(".");
+  }
+  console.log();
+  throw new BranchNexusError(
+    "2 dakika i\xE7inde tmux kurulumu alg\u0131lanamad\u0131.",
+    6 /* TMUX_ERROR */,
+    "tmux kurduktan sonra tekrar deneyin."
+  );
+}
+async function runCommand2(options) {
+  if (options.logLevel !== void 0 && options.logLevel !== "" || options.logFile !== void 0 && options.logFile !== "") {
+    configureLogging({
+      level: options.logLevel,
+      logFile: options.logFile
+    });
+  }
+  logger.info("Starting BranchNexus");
+  await ensureTmuxInstalled();
+  const config = loadConfig();
+  const sessionName = options.session ?? "branchnexus";
+  if (options.fresh !== true && config.sessionRestoreEnabled && Object.keys(config.lastSession).length > 0) {
+    const snapshot = parseRuntimeSnapshot(config.lastSession);
+    if (snapshot !== null) {
+      const restore = await p3.confirm({
+        message: "Son oturumu geri y\xFCklemek ister misiniz?",
+        initialValue: true
+      });
+      if (restore !== void 0 && restore !== null && restore === true) {
+        logger.info("Restoring previous session");
+        const platform3 = detectPlatform();
+        const isWindows2 = platform3 === "windows" /* WINDOWS */;
+        let distribution2 = "";
+        if (isWindows2 && config.wslDistribution !== "") {
+          distribution2 = config.wslDistribution;
+        }
+        const assignments2 = snapshot.terminals.map((t, i) => ({
+          pane: i,
+          repoPath: t.repoPath,
+          branch: t.branch
+        }));
+        const worktreeBase2 = expandHomeDir(
+          config.defaultRoot !== "" ? `${config.defaultRoot}/.bnx` : "~/.bnx"
+        );
+        const request2 = {
+          distribution: distribution2,
+          availableDistributions: [],
+          layout: snapshot.layout,
+          cleanupPolicy: config.cleanupPolicy,
+          assignments: assignments2,
+          worktreeBase: worktreeBase2,
+          sessionName,
+          tmuxAutoInstall: config.tmuxAutoInstall,
+          colorTheme: config.colorTheme,
+          paneNames: snapshot.terminals.map((t) => t.title),
+          displayBranches: snapshot.terminals.map((t) => t.branch)
+        };
+        const s2 = p3.spinner();
+        s2.start("Oturum geri y\xFCkleniyor...");
+        try {
+          const result = await orchestrate(request2);
+          s2.stop(`${result.worktrees.length} worktree geri y\xFCklendi`);
+          showSuccess("tmux session haz\u0131r! Ba\u011Flan\u0131l\u0131yor...");
+          try {
+            await execa("tmux", ["attach-session", "-t", sessionName], {
+              stdio: "inherit",
+              timeout: 0
+            });
+          } catch {
+            console.log();
+            console.log(chalk9.dim("tmux session devam ediyor. Tekrar ba\u011Flanmak i\xE7in:"));
+            console.log(chalk9.cyan(`  tmux attach -t ${sessionName}`));
+            console.log();
+          }
+          return;
+        } catch (error) {
+          s2.stop("Geri y\xFCkleme ba\u015Far\u0131s\u0131z, yeni oturum ba\u015Flat\u0131l\u0131yor");
+          logger.warn(`Session restore failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    }
+  }
+  const panelResult = await showPanel();
+  if (!panelResult) {
+    return;
+  }
+  const { token, repoUrl, repoUrls, layout, paneCount, cleanup } = panelResult;
+  const allRepoUrls = repoUrls.length > 0 ? repoUrls : [repoUrl];
+  const platform2 = detectPlatform();
+  const isWindows = platform2 === "windows" /* WINDOWS */;
+  let distribution = "";
+  let availableDistributions = [];
+  if (isWindows) {
+    try {
+      availableDistributions = await listDistributions();
+      if (config.wslDistribution !== "" && availableDistributions.includes(config.wslDistribution)) {
+        distribution = config.wslDistribution;
+      } else {
+        distribution = await promptWslDistribution();
+      }
+    } catch (error) {
+      showError(
+        "WSL distributions al\u0131namad\u0131",
+        error instanceof Error ? error.message : String(error)
+      );
+      return;
+    }
+  }
+  const workspaceRoot = expandHomeDir(
+    config.defaultRoot !== "" ? config.defaultRoot : "~/workspace"
+  );
+  if (!existsSync(workspaceRoot)) {
+    mkdirSync(workspaceRoot, { recursive: true });
+  }
+  const s = p3.spinner();
+  const localRepoPaths = [];
+  for (const url of allRepoUrls) {
+    let rName = basename(url.replace(".git", ""));
+    if (rName.startsWith("git@")) {
+      rName = rName.split(":").pop()?.replace(".git", "") ?? "repo";
+    }
+    const localPath = join(workspaceRoot, rName);
+    localRepoPaths.push(localPath);
+    if (existsSync(localPath) && existsSync(join(localPath, ".git"))) {
+      s.start(`Mevcut repo kullan\u0131l\u0131yor: ${rName}...`);
+      try {
+        const git = simpleGit2(localPath);
+        await git.fetch("origin");
+        s.stop("Mevcut repo: " + localPath);
+      } catch {
+        s.stop("Fetch ba\u015Far\u0131s\u0131z, local ile devam");
+      }
+    } else {
+      s.start(`Repo klonlan\u0131yor: ${rName}...`);
+      let cloneUrl = url;
+      if (token !== null && token !== "" && url.startsWith("https://")) {
+        cloneUrl = url.replace("https://", `https://${token}@`);
+      }
+      try {
+        await cloneRepository(cloneUrl, localPath);
+        s.stop("Klonland\u0131: " + localPath);
+      } catch (error) {
+        s.stop("Klonlama ba\u015Far\u0131s\u0131z");
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("403") || message.includes("Authentication failed")) {
+          showError("Kimlik do\u011Frulama ba\u015Far\u0131s\u0131z", "Private repo i\xE7in GitHub token gerekli");
+          return;
+        }
+        showError("Repo klonlanamad\u0131", message);
+        return;
+      }
+    }
+  }
+  const localRepoPath = localRepoPaths[0];
+  const allBranches = [];
+  const branchRepoMap = /* @__PURE__ */ new Map();
+  try {
+    const { listLocalBranches: listLocalBranches2 } = await Promise.resolve().then(() => (init_branch(), branch_exports));
+    for (let ri = 0; ri < localRepoPaths.length; ri++) {
+      const rPath = localRepoPaths[ri];
+      const branchResult = await listLocalBranches2(rPath);
+      if (branchResult.warning !== void 0 && branchResult.warning !== "") {
+        p3.log.warn(branchResult.warning);
+      }
+      for (const branch of branchResult.branches) {
+        const key = localRepoPaths.length > 1 ? `[${basename(rPath)}] ${branch}` : branch;
+        allBranches.push(key);
+        branchRepoMap.set(key, rPath);
+      }
+    }
+    if (allBranches.length === 0) {
+      showError("Repository'de branch bulunamad\u0131.");
+      return;
+    }
+  } catch (error) {
+    showError("Branch listesi al\u0131namad\u0131", error instanceof Error ? error.message : String(error));
+    return;
+  }
+  let branches;
+  let paneNames = [];
+  let startupCommands = [];
+  try {
+    const selected = await showBranchSelection(allBranches, paneCount);
+    if (selected === null) {
+      p3.cancel("\u0130ptal edildi.");
+      return;
+    }
+    branches = selected.branches;
+    paneNames = selected.paneNames;
+    startupCommands = selected.startupCommands ?? [];
+  } catch (error) {
+    showError("Branch se\xE7imi ba\u015Far\u0131s\u0131z", error instanceof Error ? error.message : String(error));
+    return;
+  }
+  showPreview({
+    repoUrl,
+    layout,
+    branchCount: branches.length,
+    branches,
+    cleanup
+  });
+  const confirmed = await confirmStart();
+  if (!confirmed) {
+    p3.cancel("\u0130ptal edildi.");
+    return;
+  }
+  s.start("Worktree'ler olu\u015Fturuluyor...");
+  const resolvedBranches = [];
+  const paneRepoPaths = [];
+  for (let i = 0; i < branches.length; i++) {
+    const branchKey = branches[i];
+    const actualBranch = branchKey.replace(/^\[.*?\]\s*/, "");
+    const paneRepoPath = branchRepoMap.get(branchKey) ?? localRepoPath;
+    paneRepoPaths.push(paneRepoPath);
+    const git = simpleGit2(paneRepoPath);
+    const safeName = paneNames[i].replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || `pane-${i}`;
+    const localName = `bnx-${safeName}-${i}`;
+    try {
+      try {
+        await git.branch(["-D", localName]);
+      } catch {
+      }
+      await git.branch([localName, actualBranch]);
+      logger.debug(`Created local branch ${localName} from ${actualBranch}`);
+    } catch {
+      logger.debug(`Branch ${localName} already exists, reusing`);
+    }
+    resolvedBranches.push(localName);
+  }
+  const assignments = resolvedBranches.map((branch, index) => ({
+    pane: index,
+    repoPath: paneRepoPaths[index],
+    branch
+  }));
+  const worktreeBase = expandHomeDir(
+    config.defaultRoot !== "" ? `${config.defaultRoot}/.bnx` : "~/.bnx"
+  );
+  const request = {
+    distribution,
+    availableDistributions,
+    layout,
+    cleanupPolicy: cleanup,
+    assignments,
+    worktreeBase,
+    sessionName,
+    tmuxAutoInstall: config.tmuxAutoInstall,
+    colorTheme: config.colorTheme,
+    paneNames,
+    displayBranches: branches,
+    startupCommands: startupCommands.length > 0 ? startupCommands : void 0
+  };
+  try {
+    const result = await orchestrate(request);
+    s.stop(`${result.worktrees.length} worktree olu\u015Fturuldu`);
+    const noHooks = options.hooks === false;
+    const hookCommands = config.commandHooks["post-setup"] ?? [];
+    if (!noHooks && hookCommands.length > 0) {
+      const hookSpinner = p3.spinner();
+      hookSpinner.start("Hook'lar \xE7al\u0131\u015Ft\u0131r\u0131l\u0131yor...");
+      const runner = new HookRunner({ timeoutSeconds: 60 });
+      let totalFailures = 0;
+      for (let i = 0; i < result.worktrees.length; i++) {
+        const hookResult = await runner.run(i, hookCommands, distribution || void 0);
+        if (hookResult.hasFailures) {
+          totalFailures += hookResult.executions.filter((e) => !e.success).length;
+        }
+      }
+      if (totalFailures > 0) {
+        hookSpinner.stop(chalk9.yellow(`Hook'lar tamamland\u0131 (${totalFailures} hata)`));
+      } else {
+        hookSpinner.stop("Hook'lar tamamland\u0131");
+      }
+    }
+    const snapshotData = {
+      layout,
+      templateCount: branches.length,
+      focusedTerminalId: "",
+      terminals: branches.map((branch, i) => ({
+        terminalId: `pane-${i}`,
+        title: paneNames[i] ?? `Pane ${i}`,
+        runtime: "native",
+        repoPath: localRepoPath,
+        branch
+      }))
+    };
+    updateLastSession(snapshotData);
+    showSuccess("tmux session haz\u0131r! Ba\u011Flan\u0131l\u0131yor...");
+    try {
+      await execa("tmux", ["attach-session", "-t", sessionName], {
+        stdio: "inherit",
+        timeout: 0
+      });
+    } catch {
+      console.log();
+      console.log(chalk9.dim("tmux session devam ediyor. Tekrar ba\u011Flanmak i\xE7in:"));
+      console.log(chalk9.cyan(`  tmux attach -t ${sessionName}`));
+      console.log();
+    }
+    if (cleanup === "session" && result.worktrees.length > 0) {
+      const worktreeManager = new WorktreeManager(worktreeBase, cleanup);
+      for (const wt of result.worktrees) {
+        await worktreeManager.addWorktree(
+          { pane: wt.pane, repoPath: wt.repoPath, branch: wt.branch },
+          distribution || void 0
+        );
+      }
+      const cleanupHandler = new SessionCleanupHandler(
+        worktreeManager,
+        promptCleanup,
+        distribution || void 0
+      );
+      const cleanupResult = await cleanupHandler.handleExit();
+      if (cleanupResult.removed.length > 0) {
+        console.log(chalk9.green(`\u2713 ${cleanupResult.removed.length} worktree temizlendi.`));
+      }
+      if (cleanupResult.preservedDirty.length > 0) {
+        console.log(
+          chalk9.yellow(`\u26A0 ${cleanupResult.preservedDirty.length} dirty worktree korundu.`)
+        );
+      }
+    }
+  } catch (error) {
+    s.stop("Session olu\u015Fturulamad\u0131");
+    if (error instanceof BranchNexusError) {
+      showError(error.message, error.hint);
+    } else {
+      showError("Beklenmeyen hata", error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+
+// ts-src/commands/config.ts
+init_esm_shims();
+function configCommand(action, key, value) {
+  const config = loadConfig();
+  switch (action) {
+    case "show":
+      console.log(chalk9.bold("\n\u{1F4CB} BranchNexus Configuration\n"));
+      console.log(chalk9.dim(`Location: ${getConfigPath()}
+`));
+      console.log(JSON.stringify(config, null, 2));
+      console.log();
+      break;
+    case "set":
+      if (key === void 0 || key === "" || value === void 0) {
+        console.error(chalk9.red("Usage: branchnexus config set <key> <value>"));
+        console.log(chalk9.dim("\nAvailable keys:"));
+        console.log("  defaultRoot, defaultLayout, defaultPanes, cleanupPolicy");
+        console.log("  wslDistribution, tmuxAutoInstall, sessionRestoreEnabled");
+        console.log("  githubToken, terminalMaxCount, colorTheme");
+        process.exit(1);
+      }
+      try {
+        setConfigValue(key, value);
+        console.log(chalk9.green(`
+\u2705 Set ${key} = ${value}
+`));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk9.red(`
+\u274C ${message}
+`));
+        process.exit(1);
+      }
+      break;
+    case "reset":
+      resetConfig();
+      console.log(chalk9.green("\n\u2705 Configuration reset to defaults\n"));
+      break;
+    case "export": {
+      const exportData = JSON.stringify(config, null, 2);
+      console.log(exportData);
+      break;
+    }
+    case "import": {
+      if (key === void 0 || key === "") {
+        console.error(chalk9.red("Usage: branchnexus config import <file-path>"));
+        process.exit(1);
+      }
+      try {
+        const fileContent = readFileSync(key, "utf-8");
+        const parsed = JSON.parse(fileContent);
+        const validated = AppConfigSchema.parse(parsed);
+        saveConfig(validated);
+        console.log(chalk9.green(`
+\u2705 Configuration imported from ${key}
+`));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk9.red(`
+\u274C Import ba\u015Far\u0131s\u0131z: ${message}
+`));
+        process.exit(1);
+      }
+      break;
+    }
+    default:
+      console.log(chalk9.bold("\n\u{1F4CB} Configuration Commands\n"));
+      console.log("  branchnexus config show                Show current configuration");
+      console.log("  branchnexus config set <key> <value>    Set a configuration value");
+      console.log("  branchnexus config reset                Reset to defaults");
+      console.log("  branchnexus config export               Export config as JSON");
+      console.log("  branchnexus config import <file>        Import config from JSON file");
+      console.log();
+  }
+}
+
+// ts-src/commands/kill.ts
+init_esm_shims();
+init_logger();
+var SESSION_PREFIX = "branchnexus";
+async function cleanupWorktreeDir(basePath, distribution) {
+  if (!existsSync(basePath)) {
+    return 0;
+  }
+  let removed = 0;
+  const repoDirs = readdirSync(basePath, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const repoDir of repoDirs) {
+    const repoWorktreeDir = join(basePath, repoDir.name);
+    const paneDirs = readdirSync(repoWorktreeDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const paneDir of paneDirs) {
+      const panePath = join(repoWorktreeDir, paneDir.name);
+      const gitFile = join(panePath, ".git");
+      if (!existsSync(gitFile)) {
+        continue;
+      }
+      const cmd = ["git", "-C", panePath, "worktree", "list", "--porcelain"];
+      try {
+        const result = distribution ? await runCommand(["wsl", "-d", distribution, ...cmd]) : await runCommand(cmd);
+        let mainRepoPath = "";
+        for (const line of result.stdout.split("\n")) {
+          if (line.startsWith("worktree ")) {
+            mainRepoPath = line.slice(9).trim();
+            break;
+          }
+        }
+        if (mainRepoPath !== "") {
+          const removeCmd = ["git", "-C", mainRepoPath, "worktree", "remove", "--force", panePath];
+          const removeResult = distribution ? await runCommand(["wsl", "-d", distribution, ...removeCmd]) : await runCommand(removeCmd);
+          if (removeResult.exitCode === 0) {
+            removed++;
+            logger.debug(`Removed worktree: ${panePath}`);
+          } else {
+            logger.warn(`Failed to remove worktree ${panePath}: ${removeResult.stderr}`);
+          }
+        }
+      } catch (error) {
+        logger.warn(`Error cleaning worktree ${panePath}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    try {
+      const remaining = readdirSync(repoWorktreeDir);
+      if (remaining.length === 0) {
+        const { rmSync } = await import('fs');
+        rmSync(repoWorktreeDir, { recursive: true });
+        logger.debug(`Removed empty worktree dir: ${repoWorktreeDir}`);
+      }
+    } catch {
+    }
+  }
+  try {
+    const remaining = readdirSync(basePath);
+    if (remaining.length === 0) {
+      const { rmSync } = await import('fs');
+      rmSync(basePath, { recursive: true });
+      logger.debug(`Removed empty worktree base: ${basePath}`);
+    }
+  } catch {
+  }
+  return removed;
+}
+async function cleanupWorktrees(distribution) {
+  const config = loadConfig();
+  const root = config.defaultRoot !== "" ? config.defaultRoot : expandHomeDir("~");
+  const workspaceRoot = config.defaultRoot !== "" ? config.defaultRoot : expandHomeDir("~/workspace");
+  const paths = [
+    join(root, ".bnx"),
+    join(workspaceRoot, ".bnx"),
+    join(workspaceRoot, "branchnexus-worktrees"),
+    join(root, "branchnexus-worktrees")
+  ];
+  let total = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const p6 of paths) {
+    if (seen.has(p6)) continue;
+    seen.add(p6);
+    total += await cleanupWorktreeDir(p6, distribution);
+  }
+  return total;
+}
+async function killCommand(sessionName) {
+  const config = loadConfig();
+  const distribution = config.wslDistribution || void 0;
+  const allSessions = await listSessions(distribution);
+  const bnSessions = allSessions.filter((s) => s.startsWith(SESSION_PREFIX));
+  if (bnSessions.length === 0) {
+    console.log(chalk9.yellow("\nAktif BranchNexus session bulunamad\u0131.\n"));
+    const removed2 = await cleanupWorktrees(distribution);
+    if (removed2 > 0) {
+      console.log(chalk9.green(`${removed2} orphan worktree temizlendi.
+`));
+    }
+    return;
+  }
+  let target;
+  if (sessionName !== void 0 && sessionName !== "") {
+    if (!bnSessions.includes(sessionName)) {
+      console.error(chalk9.red(`
+Session "${sessionName}" bulunamad\u0131.
+`));
+      console.log(chalk9.dim("Aktif session'lar:"));
+      for (const s of bnSessions) {
+        console.log(chalk9.dim(`  - ${s}`));
+      }
+      console.log();
+      process.exit(1);
+    }
+    target = sessionName;
+  } else if (bnSessions.length === 1) {
+    target = bnSessions[0];
+  } else {
+    const selected = await p3.select({
+      message: "Hangi session kapat\u0131ls\u0131n?",
+      options: bnSessions.map((s) => ({ value: s, label: s }))
+    });
+    if (p3.isCancel(selected)) {
+      p3.cancel("\u0130ptal edildi.");
+      return;
+    }
+    target = selected;
+  }
+  await killSession(target, distribution);
+  console.log(chalk9.green(`
+\u2713 Session "${target}" kapat\u0131ld\u0131.`));
+  const removed = await cleanupWorktrees(distribution);
+  if (removed > 0) {
+    console.log(chalk9.green(`\u2713 ${removed} worktree temizlendi.
+`));
+  } else {
+    console.log();
+  }
+}
+
+// ts-src/commands/preset.ts
+init_esm_shims();
+function presetCommand(action, name, extra) {
+  switch (action) {
+    case "list": {
+      const presets = loadPresets();
+      const entries = Object.entries(presets);
+      if (entries.length === 0) {
+        console.log(chalk9.yellow("\nKay\u0131tl\u0131 preset bulunamad\u0131.\n"));
+        console.log(chalk9.dim("Yeni preset: branchnexus preset save <isim>"));
+        console.log();
+        return;
+      }
+      console.log(chalk9.bold("\n\u{1F4CB} Preset Listesi\n"));
+      for (const [presetName, preset] of entries) {
+        const p6 = preset;
+        console.log(
+          chalk9.cyan(`  ${presetName}`) + chalk9.dim(` \u2014 layout: ${p6.layout}, panes: ${p6.panes}, cleanup: ${p6.cleanup}`)
+        );
+      }
+      console.log();
+      break;
+    }
+    case "save": {
+      if (name === void 0 || name === "") {
+        console.error(chalk9.red("Kullan\u0131m: branchnexus preset save <isim>"));
+        process.exit(1);
+      }
+      if (extra !== void 0 && extra !== "") {
+        try {
+          const parsed = JSON.parse(extra);
+          savePreset(name, parsed);
+          console.log(chalk9.green(`
+\u2713 Preset "${name}" kaydedildi.
+`));
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          console.error(chalk9.red(`
+Ge\xE7ersiz preset verisi: ${msg}
+`));
+          process.exit(1);
+        }
+      } else {
+        const preset = createPresetFromCurrentConfig(name);
+        console.log(chalk9.green(`
+\u2713 Preset "${name}" mevcut ayarlardan olu\u015Fturuldu.`));
+        console.log(
+          chalk9.dim(`  layout: ${preset.layout}, panes: ${preset.panes}, cleanup: ${preset.cleanup}`)
+        );
+        console.log();
+      }
+      break;
+    }
+    case "load": {
+      if (name === void 0 || name === "") {
+        console.error(chalk9.red("Kullan\u0131m: branchnexus preset load <isim>"));
+        process.exit(1);
+      }
+      try {
+        const preset = applyPreset(name);
+        console.log(chalk9.green(`
+\u2713 Preset "${name}" y\xFCklendi.`));
+        console.log(
+          chalk9.dim(`  layout: ${preset.layout}, panes: ${preset.panes}, cleanup: ${preset.cleanup}`)
+        );
+        console.log();
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(chalk9.red(`
+${msg}
+`));
+        process.exit(1);
+      }
+      break;
+    }
+    case "delete": {
+      if (name === void 0 || name === "") {
+        console.error(chalk9.red("Kullan\u0131m: branchnexus preset delete <isim>"));
+        process.exit(1);
+      }
+      if (!presetExists(name)) {
+        console.error(chalk9.red(`
+Preset "${name}" bulunamad\u0131.
+`));
+        process.exit(1);
+      }
+      deletePreset(name);
+      console.log(chalk9.green(`
+\u2713 Preset "${name}" silindi.
+`));
+      break;
+    }
+    case "rename": {
+      if (name === void 0 || name === "" || extra === void 0 || extra === "") {
+        console.error(chalk9.red("Kullan\u0131m: branchnexus preset rename <eski-isim> <yeni-isim>"));
+        process.exit(1);
+      }
+      try {
+        renamePreset(name, extra);
+        console.log(chalk9.green(`
+\u2713 Preset "${name}" \u2192 "${extra}" olarak yeniden adland\u0131r\u0131ld\u0131.
+`));
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(chalk9.red(`
+${msg}
+`));
+        process.exit(1);
+      }
+      break;
+    }
+    default:
+      console.log(chalk9.bold("\n\u{1F4CB} Preset Komutlar\u0131\n"));
+      console.log("  branchnexus preset list              Kay\u0131tl\u0131 preset'leri listele");
+      console.log("  branchnexus preset save <isim>       Mevcut ayarlardan preset kaydet");
+      console.log("  branchnexus preset load <isim>       Preset y\xFCkle");
+      console.log("  branchnexus preset delete <isim>     Preset sil");
+      console.log("  branchnexus preset rename <eski> <yeni>  Preset yeniden adland\u0131r");
+      console.log();
+  }
+}
+
+// ts-src/commands/status.ts
+init_esm_shims();
+async function statusCommand() {
+  const config = loadConfig();
+  const distribution = config.wslDistribution || void 0;
+  console.log(chalk9.bold("\n\u{1F4CA} BranchNexus Durum\n"));
+  console.log(chalk9.dim("Config: ") + getConfigPath());
+  console.log();
+  console.log(chalk9.bold("tmux Session'lar:"));
+  const sessions = await listSessions(distribution);
+  const bnSessions = sessions.filter((s) => s.startsWith("branchnexus"));
+  if (bnSessions.length === 0) {
+    console.log(chalk9.dim("  Aktif session yok"));
+  } else {
+    for (const s of bnSessions) {
+      console.log(chalk9.green(`  \u25CF ${s}`));
+    }
+  }
+  console.log();
+  console.log(chalk9.bold("Worktree'ler:"));
+  const root = config.defaultRoot !== "" ? config.defaultRoot : expandHomeDir("~");
+  const bnxDir = join(root, ".bnx");
+  if (existsSync(bnxDir)) {
+    try {
+      const repoDirs = readdirSync(bnxDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+      let wtCount = 0;
+      for (const repoDir of repoDirs) {
+        const repoPath = join(bnxDir, repoDir.name);
+        const paneDirs = readdirSync(repoPath, { withFileTypes: true }).filter(
+          (d) => d.isDirectory()
+        );
+        for (const paneDir of paneDirs) {
+          const gitFile = join(repoPath, paneDir.name, ".git");
+          if (existsSync(gitFile)) {
+            wtCount++;
+            console.log(chalk9.cyan(`  ${repoDir.name}/${paneDir.name}`));
+          }
+        }
+      }
+      if (wtCount === 0) {
+        console.log(chalk9.dim("  Aktif worktree yok"));
+      }
+    } catch {
+      console.log(chalk9.dim("  Worktree dizini okunamad\u0131"));
+    }
+  } else {
+    console.log(chalk9.dim("  Aktif worktree yok"));
+  }
+  console.log();
+  console.log(chalk9.bold("Preset'ler:"));
+  const presets = loadPresets();
+  const presetEntries = Object.entries(presets);
+  if (presetEntries.length === 0) {
+    console.log(chalk9.dim("  Kay\u0131tl\u0131 preset yok"));
+  } else {
+    for (const [name, preset] of presetEntries) {
+      console.log(
+        chalk9.cyan(`  ${name}`) + chalk9.dim(` \u2014 ${preset.layout}, ${preset.panes} pane, ${preset.cleanup}`)
+      );
+    }
+  }
+  console.log();
+  console.log(chalk9.bold("Hook'lar:"));
+  const hooks = config.commandHooks;
+  const hookEntries = Object.entries(hooks);
+  if (hookEntries.length === 0) {
+    console.log(chalk9.dim("  Tan\u0131ml\u0131 hook yok"));
+  } else {
+    for (const [event, commands] of hookEntries) {
+      console.log(chalk9.cyan(`  ${event}:`));
+      for (const cmd of commands) {
+        console.log(chalk9.dim(`    $ ${cmd}`));
+      }
+    }
+  }
+  console.log();
+  console.log(chalk9.bold("GitHub Token:"));
+  const hasToken = config.githubToken !== "";
+  const envToken = process.env.BRANCHNEXUS_GH_TOKEN;
+  const tokenSource = envToken !== void 0 && envToken !== "" ? " (env)" : " (config)";
+  console.log(
+    hasToken ? chalk9.green(`  \u25CF Tan\u0131ml\u0131${tokenSource}`) : chalk9.dim("  \u25CB Tan\u0131ml\u0131 de\u011Fil")
+  );
+  console.log();
+  console.log(chalk9.bold("Ayarlar:"));
+  console.log(chalk9.dim("  Layout:    ") + config.defaultLayout);
+  console.log(chalk9.dim("  Panes:     ") + config.defaultPanes);
+  console.log(chalk9.dim("  Cleanup:   ") + config.cleanupPolicy);
+  console.log(chalk9.dim("  Theme:     ") + config.colorTheme);
+  console.log(chalk9.dim("  Restore:   ") + (config.sessionRestoreEnabled ? "A\xE7\u0131k" : "Kapal\u0131"));
+  if (config.wslDistribution !== "") {
+    console.log(chalk9.dim("  WSL:       ") + config.wslDistribution);
+  }
+  console.log();
+}
+
+// ts-src/commands/attach.ts
+init_esm_shims();
+var SESSION_PREFIX2 = "branchnexus";
+async function attachCommand(sessionName) {
+  const config = loadConfig();
+  const distribution = config.wslDistribution || void 0;
+  const allSessions = await listSessions(distribution);
+  const bnSessions = allSessions.filter((s) => s.startsWith(SESSION_PREFIX2));
+  if (bnSessions.length === 0) {
+    console.log(chalk9.yellow("\nAktif BranchNexus session bulunamad\u0131.\n"));
+    console.log(chalk9.dim("Yeni session ba\u015Flatmak i\xE7in: branchnexus"));
+    console.log();
+    return;
+  }
+  let target;
+  if (sessionName !== void 0 && sessionName !== "") {
+    if (!bnSessions.includes(sessionName)) {
+      console.error(chalk9.red(`
+Session "${sessionName}" bulunamad\u0131.
+`));
+      console.log(chalk9.dim("Aktif session'lar:"));
+      for (const s of bnSessions) {
+        console.log(chalk9.dim(`  - ${s}`));
+      }
+      console.log();
+      process.exit(1);
+    }
+    target = sessionName;
+  } else if (bnSessions.length === 1) {
+    target = bnSessions[0];
+  } else {
+    const selected = await p3.select({
+      message: "Hangi session'a ba\u011Flan\u0131ls\u0131n?",
+      options: bnSessions.map((s) => ({ value: s, label: s }))
+    });
+    if (p3.isCancel(selected)) {
+      p3.cancel("\u0130ptal edildi.");
+      return;
+    }
+    target = selected;
+  }
+  console.log(chalk9.cyan(`
+Session "${target}" ba\u011Flan\u0131l\u0131yor...
+`));
+  try {
+    await execa("tmux", ["attach-session", "-t", target], {
+      stdio: "inherit",
+      timeout: 0
+    });
+  } catch {
+    console.log();
+    console.log(chalk9.dim("tmux session devam ediyor. Tekrar ba\u011Flanmak i\xE7in:"));
+    console.log(chalk9.cyan(`  branchnexus attach ${target}`));
+    console.log();
+  }
+}
+
+// ts-src/prompts/setup.ts
+init_esm_shims();
+init_logger();
+async function checkDependencies() {
+  const tmuxInstalled = await hasTmux();
+  let gitInstalled = false;
+  try {
+    await execa("git", ["--version"]);
+    gitInstalled = true;
+  } catch {
+    gitInstalled = false;
+  }
+  return { tmux: tmuxInstalled, git: gitInstalled };
+}
+async function installTmux() {
+  const platform2 = detectPlatform();
+  console.log(chalk9.dim("\n\u{1F4E6} Installing tmux...\n"));
+  let cmd;
+  if (platform2 === "macos" /* MACOS */) {
+    cmd = "brew install tmux";
+  } else {
+    try {
+      await execa("bash", ["-lc", "which apt-get"]);
+      cmd = "sudo apt-get update && sudo apt-get install -y tmux";
+    } catch {
+      try {
+        await execa("bash", ["-lc", "which dnf"]);
+        cmd = "sudo dnf install -y tmux";
+      } catch {
+        try {
+          await execa("bash", ["-lc", "which pacman"]);
+          cmd = "sudo pacman -S --noconfirm tmux";
+        } catch {
+          console.log(chalk9.red("Could not detect package manager. Please install tmux manually."));
+          return false;
+        }
+      }
+    }
+  }
+  console.log(chalk9.dim(`Running: ${cmd}`));
+  try {
+    if (cmd.includes("sudo")) {
+      console.log(chalk9.yellow("\n\u26A0\uFE0F  sudo password required. Running in your shell...\n"));
+      console.log(chalk9.cyan(`Please run: ${cmd}
+`));
+      const { proceed } = await inquirer2.prompt([
+        {
+          type: "confirm",
+          name: "proceed",
+          message: "Press Enter after you have run the command above",
+          default: true
+        }
+      ]);
+      return proceed;
+    } else {
+      await execa("bash", ["-lc", cmd]);
+      console.log(chalk9.green("\u2705 tmux installed successfully!\n"));
+      return true;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(chalk9.red(`Failed to install tmux: ${message}`));
+    console.log(chalk9.dim(`Please run manually: ${cmd}`));
+    return false;
+  }
+}
+async function promptSetup() {
+  console.log(chalk9.cyan.bold("\n\u{1F680} BranchNexus Setup Wizard\n"));
+  const platform2 = detectPlatform();
+  const currentConfig = loadConfig();
+  const deps = await checkDependencies();
+  if (!deps.git) {
+    console.log(chalk9.red("\u274C Git is not installed. Please install Git first."));
+    console.log(chalk9.dim("https://git-scm.com/downloads\n"));
+    process.exit(1);
+  }
+  if (!deps.tmux) {
+    console.log(chalk9.yellow("\u26A0\uFE0F  tmux is not installed.\n"));
+    const { installTmuxNow } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "installTmuxNow",
+        message: "Install tmux automatically?",
+        default: true
+      }
+    ]);
+    if (installTmuxNow) {
+      const installed = await installTmux();
+      if (!installed) {
+        console.log(chalk9.red("\n\u274C tmux installation failed or was skipped."));
+        console.log(chalk9.dim("Please install tmux manually and run branchnexus init again.\n"));
+        process.exit(1);
+      }
+    } else {
+      console.log(chalk9.dim("\nPlease install tmux manually:"));
+      if (platform2 === "macos" /* MACOS */) {
+        console.log(chalk9.cyan("  brew install tmux"));
+      } else {
+        console.log(chalk9.cyan("  sudo apt-get install tmux"));
+      }
+      console.log();
+      process.exit(1);
+    }
+  } else {
+    console.log(chalk9.green("\u2705 tmux is installed\n"));
+  }
+  const answers = await inquirer2.prompt([
+    {
+      type: "input",
+      name: "defaultRoot",
+      message: "Default working directory:",
+      default: currentConfig.defaultRoot || "~/workspace"
+    },
+    {
+      type: "list",
+      name: "layout",
+      message: "Default layout:",
+      choices: [
+        { name: "grid (2x2)", value: "grid" },
+        { name: "horizontal (side by side)", value: "horizontal" },
+        { name: "vertical (stacked)", value: "vertical" }
+      ],
+      default: currentConfig.defaultLayout
+    },
+    {
+      type: "number",
+      name: "panes",
+      message: "Default number of panes (2-6):",
+      default: currentConfig.defaultPanes,
+      validate: (value) => {
+        if (value < 2 || value > 6) {
+          return "Panes must be between 2 and 6";
+        }
+        return true;
+      }
+    },
+    {
+      type: "list",
+      name: "cleanup",
+      message: "Cleanup policy:",
+      choices: [
+        { name: "session (delete worktrees on exit)", value: "session" },
+        { name: "persistent (keep worktrees)", value: "persistent" }
+      ],
+      default: currentConfig.cleanupPolicy
+    },
+    ...platform2 === "windows" /* WINDOWS */ ? [
+      {
+        type: "list",
+        name: "wslDistribution",
+        message: "WSL distribution:",
+        choices: async () => {
+          try {
+            const distros = await listDistributions();
+            return distros.map((d) => ({ name: d, value: d }));
+          } catch {
+            return [{ name: "No WSL distributions found", value: "" }];
+          }
+        },
+        default: currentConfig.wslDistribution
+      }
+    ] : [],
+    {
+      type: "confirm",
+      name: "githubTokenPrompt",
+      message: "Configure GitHub token for private repos?",
+      default: false
+    },
+    {
+      type: "password",
+      name: "githubToken",
+      message: "GitHub token (optional):",
+      mask: "*",
+      when: (answers2) => answers2.githubTokenPrompt
+    },
+    {
+      type: "confirm",
+      name: "saveConfig",
+      message: "Save configuration?",
+      default: true
+    }
+  ]);
+  return {
+    defaultRoot: answers.defaultRoot,
+    defaultLayout: answers.layout,
+    defaultPanes: answers.panes,
+    cleanupPolicy: answers.cleanup,
+    wslDistribution: answers.wslDistribution,
+    githubToken: answers.githubToken
+  };
+}
+async function initCommand() {
+  logger.info("Starting init wizard");
+  console.log(chalk9.bold("\n\u{1F4CB} BranchNexus Setup\n"));
+  console.log("This wizard will help you configure BranchNexus for your workflow.\n");
+  const partialConfig = await promptSetup();
+  const config = loadConfig();
+  const merged = {
+    ...DEFAULT_CONFIG,
+    ...config,
+    ...partialConfig
+  };
+  if (partialConfig.wslDistribution !== void 0 && partialConfig.wslDistribution !== "") {
+    setWslDistribution(partialConfig.wslDistribution);
+  }
+  if (partialConfig.githubToken !== void 0 && partialConfig.githubToken !== "") {
+    setGithubToken(partialConfig.githubToken);
+  }
+  saveConfig(merged);
+  console.log(chalk9.green("\n\u2705 Configuration saved!\n"));
+  console.log(chalk9.dim(`Config location: ${process.env.HOME}/.config/branchnexus/config.json`));
+  console.log(chalk9.dim("\nRun `branchnexus` to start a session.\n"));
+}
+
+// ts-src/cli.ts
+init_errors();
+init_logger();
+var program = new Command();
+program.name("branchnexus").description("Multi-branch workspace orchestrator for tmux").version("1.0.0");
+program.command("init").description("First-time setup wizard").action(async () => {
+  await initCommand();
+});
+program.command("config").description("Manage configuration (show | set | reset | export | import)").argument("[action]", "show | set | reset | export | import").argument("[key]", "Config key or file path").argument("[value]", "Config value").action((action, key, value) => {
+  configCommand(action, key, value);
+});
+program.command("kill").description("Kill an active BranchNexus tmux session").argument("[session]", "Session name to kill").action(async (session) => {
+  await killCommand(session);
+});
+program.command("preset").description("Manage presets (list | save | load | delete | rename)").argument("[action]", "list | save | load | delete | rename").argument("[name]", "Preset name").argument("[extra]", "JSON data or new name for rename").action((action, name, extra) => {
+  presetCommand(action, name, extra);
+});
+program.command("status").description("Show BranchNexus status overview").action(async () => {
+  await statusCommand();
+});
+program.command("attach").description("Attach to a detached BranchNexus tmux session").argument("[session]", "Session name to attach").action(async (session) => {
+  await attachCommand(session);
+});
+program.option("--root <path>", "Working directory").option("--layout <layout>", "horizontal | vertical | grid").option("--panes <number>", "Number of panes (2-6)", parseInt).option("--cleanup <policy>", "session | persistent").option("--fresh", "Reset workspace and start fresh").option("--terminal-template <template>", "2 | 4 | 6 | 8 | 12 | 16 | custom").option("--max-terminals <count>", "Maximum terminals", parseInt).option("--log-level <level>", "DEBUG | INFO | WARN | ERROR").option("--log-file <path>", "Log file path").option("--session <name>", "Custom session name").option("--no-hooks", "Skip command hooks");
+program.action(async (options) => {
+  await runCommand2(options);
+});
+async function main() {
+  const logPath = defaultLogPath();
+  configureLogging({ logFile: logPath });
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (isBranchNexusError(error)) {
+      logger.error(`BranchNexusError: ${error.message}`);
+      console.error(chalk9.red(userFacingError(error.message, error.hint)));
+      process.exit(error.code);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Unexpected error: ${message}`);
+    console.error(
+      chalk9.red(userFacingError("Unexpected runtime failure", `Check logs: ${logPath}`))
+    );
+    process.exit(4 /* RUNTIME_ERROR */);
+  }
+}
+void main();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map