git-tidy-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1154 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { render } from "ink";
+
+// src/app.tsx
+import { useState as useState5, useEffect as useEffect2, useCallback as useCallback2 } from "react";
+import { Box as Box8, Text as Text8 } from "ink";
+import { Spinner as Spinner2 } from "@inkjs/ui";
+
+// src/components/Header.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Header({ repoInfo }) {
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "cyan",
+      paddingX: 2,
+      paddingY: 0,
+      marginBottom: 1,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "git-tidy" }),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: " - Branch Cleanup Tool" })
+        ] }),
+        repoInfo && /* @__PURE__ */ jsxs(Box, { gap: 2, children: [
+          /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+            "Repository:",
+            " ",
+            /* @__PURE__ */ jsxs(Text, { color: "white", children: [
+              repoInfo.owner,
+              "/",
+              repoInfo.repo
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+            "Branch:",
+            " ",
+            /* @__PURE__ */ jsx(Text, { color: "green", children: repoInfo.currentBranch })
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+            "Default:",
+            " ",
+            /* @__PURE__ */ jsx(Text, { color: "yellow", children: repoInfo.defaultBranch })
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/ScopeStep.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { Select } from "@inkjs/ui";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function ScopeStep({ onSelect }) {
+  const options2 = [
+    {
+      label: "Both local and remote branches",
+      value: "both"
+    },
+    {
+      label: "Local branches only",
+      value: "local"
+    },
+    {
+      label: "Remote branches only",
+      value: "remote"
+    }
+  ];
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", bold: true, children: "Step 1:" }),
+      /* @__PURE__ */ jsx2(Text2, { children: " What would you like to clean up?" })
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { marginLeft: 2, children: /* @__PURE__ */ jsx2(
+      Select,
+      {
+        options: options2,
+        onChange: (value) => onSelect(value)
+      }
+    ) }),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { color: "gray", dimColor: true, children: "Use \u2191\u2193 to navigate, Enter to select" }) })
+  ] });
+}
+
+// src/components/CriteriaStep.tsx
+import { useState } from "react";
+import { Box as Box3, Text as Text3, useInput } from "ink";
+import { MultiSelect, TextInput } from "@inkjs/ui";
+
+// src/utils/config.ts
+var DEFAULT_STALE_DAYS = 30;
+var DEFAULT_AGE_DAYS = 60;
+var PROTECTED_PATTERNS = [
+  "main",
+  "master",
+  "develop",
+  "development",
+  "staging",
+  "production",
+  "release/*"
+];
+function matchesProtectedPattern(branchName) {
+  return PROTECTED_PATTERNS.some((pattern) => {
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -2);
+      return branchName.startsWith(prefix + "/");
+    }
+    return branchName === pattern;
+  });
+}
+
+// src/components/CriteriaStep.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function CriteriaStep({ onSelect, onBack }) {
+  const [selectedCriteria, setSelectedCriteria] = useState([]);
+  const [inputMode, setInputMode] = useState("select");
+  const [staleDays, setStaleDays] = useState(String(DEFAULT_STALE_DAYS));
+  const [ageDays, setAgeDays] = useState(String(DEFAULT_AGE_DAYS));
+  const [pattern, setPattern] = useState("feature/*");
+  const [inputError, setInputError] = useState(null);
+  const validateNumber = (value) => {
+    const num = parseInt(value, 10);
+    if (isNaN(num) || num <= 0) {
+      return null;
+    }
+    return num;
+  };
+  const options2 = [
+    {
+      label: "Merged branches (already merged into default branch)",
+      value: "merged"
+    },
+    {
+      label: `Stale branches (no commits in ${staleDays} days)`,
+      value: "stale"
+    },
+    {
+      label: `Branches older than ${ageDays} days`,
+      value: "age"
+    },
+    {
+      label: `Pattern matching: ${pattern}`,
+      value: "pattern"
+    }
+  ];
+  useInput((input, key) => {
+    if (key.escape) {
+      if (inputMode !== "select") {
+        setInputMode("select");
+      } else {
+        onBack();
+      }
+    }
+    if (key.return && inputMode === "select") {
+      handleSubmit();
+    }
+  });
+  const handleCriteriaChange = (values) => {
+    setSelectedCriteria(values);
+  };
+  const handleSubmit = () => {
+    if (selectedCriteria.includes("stale") && inputMode === "select") {
+      setInputMode("staleDays");
+      return;
+    }
+    if (selectedCriteria.includes("age") && inputMode === "staleDays") {
+      setInputMode("ageDays");
+      return;
+    }
+    if (selectedCriteria.includes("pattern") && inputMode === "ageDays") {
+      setInputMode("pattern");
+      return;
+    }
+    if (selectedCriteria.includes("pattern") && inputMode === "select") {
+      setInputMode("pattern");
+      return;
+    }
+    const filters = {
+      merged: selectedCriteria.includes("merged"),
+      stale: selectedCriteria.includes("stale"),
+      staleDays: parseInt(staleDays, 10) || DEFAULT_STALE_DAYS,
+      pattern: selectedCriteria.includes("pattern"),
+      patternValue: pattern,
+      age: selectedCriteria.includes("age"),
+      ageDays: parseInt(ageDays, 10) || DEFAULT_AGE_DAYS
+    };
+    onSelect(filters);
+  };
+  if (inputMode === "staleDays") {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", gap: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "How many days without commits is considered stale?" }),
+      /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx3(
+          TextInput,
+          {
+            defaultValue: staleDays,
+            onSubmit: (value) => {
+              const num = validateNumber(value);
+              if (num === null) {
+                setInputError("Please enter a valid number greater than 0");
+                return;
+              }
+              setInputError(null);
+              setStaleDays(String(num));
+              if (selectedCriteria.includes("age")) {
+                setInputMode("ageDays");
+              } else if (selectedCriteria.includes("pattern")) {
+                setInputMode("pattern");
+              } else {
+                handleSubmit();
+              }
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx3(Text3, { color: "gray", children: " days" })
+      ] }),
+      inputError && /* @__PURE__ */ jsx3(Text3, { color: "red", children: inputError })
+    ] });
+  }
+  if (inputMode === "ageDays") {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", gap: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "How many days old should a branch be?" }),
+      /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx3(
+          TextInput,
+          {
+            defaultValue: ageDays,
+            onSubmit: (value) => {
+              const num = validateNumber(value);
+              if (num === null) {
+                setInputError("Please enter a valid number greater than 0");
+                return;
+              }
+              setInputError(null);
+              setAgeDays(String(num));
+              if (selectedCriteria.includes("pattern")) {
+                setInputMode("pattern");
+              } else {
+                handleSubmit();
+              }
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx3(Text3, { color: "gray", children: " days" })
+      ] }),
+      inputError && /* @__PURE__ */ jsx3(Text3, { color: "red", children: inputError })
+    ] });
+  }
+  if (inputMode === "pattern") {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", gap: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "Enter branch name pattern (use * as wildcard):" }),
+      /* @__PURE__ */ jsx3(
+        TextInput,
+        {
+          defaultValue: pattern,
+          onSubmit: (value) => {
+            setPattern(value);
+            const filters = {
+              merged: selectedCriteria.includes("merged"),
+              stale: selectedCriteria.includes("stale"),
+              staleDays: parseInt(staleDays, 10) || DEFAULT_STALE_DAYS,
+              pattern: selectedCriteria.includes("pattern"),
+              patternValue: value,
+              age: selectedCriteria.includes("age"),
+              ageDays: parseInt(ageDays, 10) || DEFAULT_AGE_DAYS
+            };
+            onSelect(filters);
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx3(Text3, { color: "gray", dimColor: true, children: "Examples: feature/*, hotfix/*, *-old, test-*" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", bold: true, children: "Step 2:" }),
+      /* @__PURE__ */ jsx3(Text3, { children: " Which branches should be included? (select multiple)" })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { marginLeft: 2, children: /* @__PURE__ */ jsx3(
+      MultiSelect,
+      {
+        options: options2,
+        onChange: handleCriteriaChange
+      }
+    ) }),
+    /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "gray", dimColor: true, children: "Use \u2191\u2193 to navigate, Space to toggle, Enter to confirm" }),
+      /* @__PURE__ */ jsx3(Text3, { color: "gray", dimColor: true, children: "Press Esc to go back" })
+    ] }),
+    selectedCriteria.length > 0 && /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsxs3(Text3, { color: "green", children: [
+      "Press Enter to continue with ",
+      selectedCriteria.length,
+      " filter(s)"
+    ] }) })
+  ] });
+}
+
+// src/components/BranchSelectStep.tsx
+import { useState as useState2, useMemo } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
+import { MultiSelect as MultiSelect2 } from "@inkjs/ui";
+
+// src/utils/date.ts
+function daysAgo(date) {
+  const now = /* @__PURE__ */ new Date();
+  const diffTime = Math.abs(now.getTime() - date.getTime());
+  const diffDays = Math.floor(diffTime / (1e3 * 60 * 60 * 24));
+  return diffDays;
+}
+function formatDaysAgo(date) {
+  const days = daysAgo(date);
+  if (days === 0) {
+    return "today";
+  } else if (days === 1) {
+    return "1 day ago";
+  } else if (days < 7) {
+    return `${days} days ago`;
+  } else if (days < 30) {
+    const weeks = Math.floor(days / 7);
+    return weeks === 1 ? "1 week ago" : `${weeks} weeks ago`;
+  } else if (days < 365) {
+    const months = Math.floor(days / 30);
+    return months === 1 ? "1 month ago" : `${months} months ago`;
+  } else {
+    const years = Math.floor(days / 365);
+    return years === 1 ? "1 year ago" : `${years} years ago`;
+  }
+}
+function isOlderThan(date, days) {
+  return daysAgo(date) > days;
+}
+
+// src/components/BranchSelectStep.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function BranchSelectStep({
+  branches,
+  onSelect,
+  onBack
+}) {
+  const [selectedValues, setSelectedValues] = useState2([]);
+  const options2 = useMemo(() => {
+    return branches.map((branch) => {
+      const location = branch.isLocal && branch.isRemote ? "local+remote" : branch.isLocal ? "local" : "remote";
+      const status = branch.isMerged ? "merged" : "not merged";
+      const age = formatDaysAgo(branch.lastCommitDate);
+      return {
+        label: `${branch.name}`,
+        value: branch.name,
+        hint: `(${status}, ${age}, ${location})`
+      };
+    });
+  }, [branches]);
+  useInput2((input, key) => {
+    if (key.escape) {
+      onBack();
+      return;
+    }
+    if (key.return && selectedValues.length > 0) {
+      const selected = branches.filter((b) => selectedValues.includes(b.name));
+      onSelect(selected);
+      return;
+    }
+    if (input === "a") {
+      setSelectedValues(branches.map((b) => b.name));
+    }
+    if (input === "n") {
+      setSelectedValues([]);
+    }
+    if (input === "i") {
+      const inverted = branches.filter((b) => !selectedValues.includes(b.name)).map((b) => b.name);
+      setSelectedValues(inverted);
+    }
+  });
+  const handleChange = (values) => {
+    setSelectedValues(values);
+  };
+  const handleSubmit = () => {
+    const selected = branches.filter((b) => selectedValues.includes(b.name));
+    onSelect(selected);
+  };
+  if (branches.length === 0) {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", gap: 1, children: [
+      /* @__PURE__ */ jsxs4(Box4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "Step 3:" }),
+        /* @__PURE__ */ jsx4(Text4, { children: " Select branches to delete" })
+      ] }),
+      /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: "No branches match your criteria." }) }),
+      /* @__PURE__ */ jsx4(Text4, { color: "gray", dimColor: true, children: "Press Esc to go back and adjust filters" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "Step 3:" }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        " Select branches to delete (",
+        branches.length,
+        " found)"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box4, { marginLeft: 2, gap: 2, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "[a] Select all" }),
+      /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "[n] Select none" }),
+      /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "[i] Invert" })
+    ] }),
+    /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, flexDirection: "column", children: /* @__PURE__ */ jsx4(
+      MultiSelect2,
+      {
+        options: options2,
+        defaultValue: selectedValues,
+        onChange: handleChange
+      }
+    ) }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsx4(Text4, { color: "gray", dimColor: true, children: "\u2191\u2193 navigate, Space toggle, Enter confirm, Esc back" }) }),
+    /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, children: [
+      /* @__PURE__ */ jsxs4(Text4, { color: selectedValues.length > 0 ? "green" : "gray", children: [
+        selectedValues.length,
+        " branch(es) selected"
+      ] }),
+      selectedValues.length > 0 && /* @__PURE__ */ jsx4(Text4, { color: "gray", children: " - Press Enter to continue" })
+    ] })
+  ] });
+}
+
+// src/components/ConfirmStep.tsx
+import { Box as Box5, Text as Text5, useInput as useInput3 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function ConfirmStep({
+  branches,
+  isDryRun,
+  onConfirm,
+  onCancel
+}) {
+  const localCount = branches.filter((b) => b.isLocal).length;
+  const remoteCount = branches.filter((b) => b.isRemote).length;
+  useInput3((input, key) => {
+    if (key.return) {
+      onConfirm();
+    }
+    if (key.escape || input === "n" || input === "N") {
+      onCancel();
+    }
+    if (input === "y" || input === "Y") {
+      onConfirm();
+    }
+  });
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", bold: true, children: "Step 4:" }),
+      /* @__PURE__ */ jsx5(Text5, { children: " Confirm deletion" })
+    ] }),
+    /* @__PURE__ */ jsxs5(
+      Box5,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: "yellow",
+        paddingX: 2,
+        paddingY: 1,
+        marginY: 1,
+        children: [
+          /* @__PURE__ */ jsxs5(Text5, { bold: true, children: [
+            "Ready to delete ",
+            branches.length,
+            " branch(es)"
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, gap: 2, children: [
+            /* @__PURE__ */ jsxs5(Text5, { children: [
+              "Local: ",
+              /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: localCount })
+            ] }),
+            /* @__PURE__ */ jsxs5(Text5, { children: [
+              "Remote: ",
+              /* @__PURE__ */ jsx5(Text5, { color: "magenta", children: remoteCount })
+            ] })
+          ] }),
+          isDryRun && /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { color: "yellow", bold: true, children: "DRY RUN MODE - No branches will actually be deleted" }) }),
+          !isDryRun && /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { color: "red", bold: true, children: "WARNING: This will permanently delete these branches!" }) })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Branches to delete:" }),
+      /* @__PURE__ */ jsxs5(Box5, { marginLeft: 2, flexDirection: "column", children: [
+        branches.slice(0, 10).map((branch) => /* @__PURE__ */ jsxs5(Text5, { color: "gray", children: [
+          "- ",
+          branch.name,
+          " ",
+          /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+            "(",
+            branch.isLocal && "local",
+            branch.isLocal && branch.isRemote && ", ",
+            branch.isRemote && "remote",
+            ")"
+          ] })
+        ] }, branch.name)),
+        branches.length > 10 && /* @__PURE__ */ jsxs5(Text5, { color: "gray", dimColor: true, children: [
+          "... and ",
+          branches.length - 10,
+          " more"
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, gap: 2, children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "green", children: "[Enter/Y] Confirm" }),
+      /* @__PURE__ */ jsx5(Text5, { color: "red", children: "[Esc/N] Cancel" })
+    ] })
+  ] });
+}
+
+// src/components/ExecutionStep.tsx
+import { useEffect, useState as useState3 } from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+import { Spinner } from "@inkjs/ui";
+
+// src/services/git.ts
+import simpleGit from "simple-git";
+var git;
+function initGit(cwd) {
+  git = simpleGit(cwd);
+  return git;
+}
+async function isGitRepo() {
+  try {
+    await git.revparse(["--git-dir"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getCurrentBranch() {
+  const result = await git.revparse(["--abbrev-ref", "HEAD"]);
+  return result.trim();
+}
+async function getRemoteInfo() {
+  try {
+    const remotes = await git.getRemotes(true);
+    const origin = remotes.find((r) => r.name === "origin");
+    if (!origin?.refs?.fetch) {
+      return null;
+    }
+    const url = origin.refs.fetch;
+    const sshMatch = url.match(/git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+    const httpsMatch = url.match(/https:\/\/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/);
+    const match = sshMatch || httpsMatch;
+    if (match) {
+      return {
+        owner: match[1],
+        repo: match[2],
+        isGitHub: true
+      };
+    }
+    return { owner: "", repo: "", isGitHub: false };
+  } catch {
+    return null;
+  }
+}
+async function getLocalBranches(defaultBranch, currentBranch) {
+  const branches = [];
+  try {
+    const branchSummary = await git.branchLocal();
+    for (const branchName of branchSummary.all) {
+      const logResult = await git.log({
+        [branchName]: null,
+        maxCount: 1,
+        format: { date: "%aI" }
+      });
+      const lastCommitDate = logResult.latest?.date ? new Date(logResult.latest.date) : /* @__PURE__ */ new Date();
+      const isMerged = await isBranchMerged(branchName, defaultBranch);
+      const isProtected = branchName === defaultBranch || matchesProtectedPattern(branchName);
+      branches.push({
+        name: branchName,
+        isLocal: true,
+        isRemote: false,
+        lastCommitDate,
+        isMerged,
+        isProtected,
+        isCurrentBranch: branchName === currentBranch
+      });
+    }
+  } catch (error) {
+    console.error("Error getting local branches:", error);
+  }
+  return branches;
+}
+async function getRemoteBranches(defaultBranch) {
+  const branches = [];
+  try {
+    await git.fetch(["--prune"]);
+    const result = await git.branch(["-r"]);
+    for (const branchName of result.all) {
+      if (branchName.includes("HEAD")) continue;
+      const shortName = branchName.replace(/^origin\//, "");
+      if (shortName === defaultBranch) continue;
+      const logResult = await git.log({
+        [branchName]: null,
+        maxCount: 1,
+        format: { date: "%aI" }
+      });
+      const lastCommitDate = logResult.latest?.date ? new Date(logResult.latest.date) : /* @__PURE__ */ new Date();
+      const isMerged = await isBranchMerged(branchName, `origin/${defaultBranch}`);
+      const isProtected = shortName === defaultBranch || matchesProtectedPattern(shortName);
+      branches.push({
+        name: shortName,
+        isLocal: false,
+        isRemote: true,
+        lastCommitDate,
+        isMerged,
+        isProtected,
+        isCurrentBranch: false
+      });
+    }
+  } catch (error) {
+    console.error("Error getting remote branches:", error);
+  }
+  return branches;
+}
+async function isBranchMerged(branch, target) {
+  try {
+    const result = await git.raw(["branch", "--merged", target]);
+    const mergedBranches = result.split("\n").map((b) => b.trim().replace(/^\*\s*/, ""));
+    return mergedBranches.includes(branch) || mergedBranches.includes(branch.replace(/^origin\//, ""));
+  } catch {
+    return false;
+  }
+}
+async function deleteLocalBranch(branchName, force = false) {
+  const flag = force ? "-D" : "-d";
+  await git.branch([flag, branchName]);
+}
+async function deleteRemoteBranch(branchName, remote = "origin") {
+  await git.push([remote, "--delete", branchName]);
+}
+async function getRepoInfo(defaultBranch) {
+  try {
+    const currentBranch = await getCurrentBranch();
+    const remoteInfo = await getRemoteInfo();
+    return {
+      owner: remoteInfo?.owner || "",
+      repo: remoteInfo?.repo || "",
+      defaultBranch: defaultBranch || "main",
+      currentBranch,
+      isGitHub: remoteInfo?.isGitHub || false
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/components/ExecutionStep.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function ExecutionStep({
+  branches,
+  isDryRun,
+  onComplete
+}) {
+  const [currentIndex, setCurrentIndex] = useState3(0);
+  const [results, setResults] = useState3([]);
+  const [isDeleting, setIsDeleting] = useState3(true);
+  useEffect(() => {
+    const deleteBranches = async () => {
+      const allResults = [];
+      for (let i = 0; i < branches.length; i++) {
+        const branch = branches[i];
+        setCurrentIndex(i);
+        const result = {
+          branch,
+          success: true,
+          deletedLocal: false,
+          deletedRemote: false
+        };
+        if (isDryRun) {
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          result.deletedLocal = branch.isLocal;
+          result.deletedRemote = branch.isRemote;
+        } else {
+          try {
+            if (branch.isLocal) {
+              await deleteLocalBranch(branch.name, true);
+              result.deletedLocal = true;
+            }
+          } catch (error) {
+            result.success = false;
+            result.error = `Local: ${error instanceof Error ? error.message : "Unknown error"}`;
+          }
+          try {
+            if (branch.isRemote) {
+              await deleteRemoteBranch(branch.name);
+              result.deletedRemote = true;
+            }
+          } catch (error) {
+            if (!result.error) {
+              result.success = false;
+              result.error = `Remote: ${error instanceof Error ? error.message : "Unknown error"}`;
+            } else {
+              result.error += `; Remote: ${error instanceof Error ? error.message : "Unknown error"}`;
+            }
+          }
+        }
+        allResults.push(result);
+        setResults([...allResults]);
+      }
+      setIsDeleting(false);
+      const summary = {
+        total: branches.length,
+        successful: allResults.filter((r) => r.success).length,
+        failed: allResults.filter((r) => !r.success).length,
+        skipped: 0,
+        results: allResults
+      };
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      onComplete(summary);
+    };
+    deleteBranches();
+  }, [branches, isDryRun, onComplete]);
+  const currentBranch = branches[currentIndex];
+  const completedCount = results.length;
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxs6(Box6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "cyan", bold: true, children: "Step 5:" }),
+      /* @__PURE__ */ jsxs6(Text6, { children: [
+        " ",
+        isDryRun ? "Simulating deletion..." : "Deleting branches..."
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs6(
+      Box6,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: "blue",
+        paddingX: 2,
+        paddingY: 1,
+        children: [
+          isDeleting && currentBranch && /* @__PURE__ */ jsxs6(Box6, { gap: 1, children: [
+            /* @__PURE__ */ jsx6(Spinner, { label: "" }),
+            /* @__PURE__ */ jsxs6(Text6, { children: [
+              isDryRun ? "Processing" : "Deleting",
+              " ",
+              currentBranch.name
+            ] }),
+            /* @__PURE__ */ jsxs6(Text6, { color: "gray", children: [
+              "(",
+              completedCount + 1,
+              "/",
+              branches.length,
+              ")"
+            ] })
+          ] }),
+          !isDeleting && /* @__PURE__ */ jsxs6(Text6, { color: "green", children: [
+            isDryRun ? "Simulation" : "Deletion",
+            " complete!"
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "gray", children: "Results:" }),
+      /* @__PURE__ */ jsxs6(Box6, { marginLeft: 2, flexDirection: "column", children: [
+        results.slice(-8).map((result, index) => /* @__PURE__ */ jsxs6(Box6, { gap: 1, children: [
+          /* @__PURE__ */ jsx6(Text6, { color: result.success ? "green" : "red", children: result.success ? "\u2713" : "\u2717" }),
+          /* @__PURE__ */ jsx6(Text6, { color: result.success ? "gray" : "red", children: result.branch.name }),
+          result.deletedLocal && /* @__PURE__ */ jsx6(Text6, { color: "cyan", dimColor: true, children: "(local)" }),
+          result.deletedRemote && /* @__PURE__ */ jsx6(Text6, { color: "magenta", dimColor: true, children: "(remote)" }),
+          result.error && /* @__PURE__ */ jsxs6(Text6, { color: "red", dimColor: true, children: [
+            "- ",
+            result.error
+          ] })
+        ] }, result.branch.name)),
+        results.length > 8 && /* @__PURE__ */ jsxs6(Text6, { color: "gray", dimColor: true, children: [
+          "... and ",
+          results.length - 8,
+          " more"
+        ] })
+      ] })
+    ] })
+  ] });
+}
+
+// src/components/SummaryStep.tsx
+import { Box as Box7, Text as Text7, useInput as useInput4, useApp } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function SummaryStep({ summary, isDryRun, onDeleteForReal }) {
+  const { exit } = useApp();
+  useInput4((input, key) => {
+    if (isDryRun && (input === "d" || input === "D")) {
+      onDeleteForReal?.();
+      return;
+    }
+    if (input === "q" || input === "Q" || key.escape) {
+      exit();
+      return;
+    }
+    if (!isDryRun) {
+      exit();
+    }
+  });
+  const successColor = summary.successful > 0 ? "green" : "gray";
+  const failedColor = summary.failed > 0 ? "red" : "gray";
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx7(Box7, { children: /* @__PURE__ */ jsx7(Text7, { color: "cyan", bold: true, children: isDryRun ? "Dry Run Complete!" : "Cleanup Complete!" }) }),
+    /* @__PURE__ */ jsx7(
+      Box7,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: summary.failed > 0 ? "yellow" : "green",
+        paddingX: 2,
+        paddingY: 1,
+        children: /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", gap: 0, children: [
+          /* @__PURE__ */ jsxs7(Box7, { gap: 1, children: [
+            /* @__PURE__ */ jsx7(Text7, { color: successColor, children: "\u2713" }),
+            /* @__PURE__ */ jsxs7(Text7, { children: [
+              summary.successful,
+              " branch(es)",
+              " ",
+              isDryRun ? "would be deleted" : "deleted successfully"
+            ] })
+          ] }),
+          summary.failed > 0 && /* @__PURE__ */ jsxs7(Box7, { gap: 1, children: [
+            /* @__PURE__ */ jsx7(Text7, { color: failedColor, children: "\u2717" }),
+            /* @__PURE__ */ jsxs7(Text7, { color: failedColor, children: [
+              summary.failed,
+              " branch(es) failed"
+            ] })
+          ] }),
+          summary.skipped > 0 && /* @__PURE__ */ jsxs7(Box7, { gap: 1, children: [
+            /* @__PURE__ */ jsx7(Text7, { color: "gray", children: "\u25CB" }),
+            /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+              summary.skipped,
+              " branch(es) skipped"
+            ] })
+          ] })
+        ] })
+      }
+    ),
+    isDryRun && summary.successful > 0 && /* @__PURE__ */ jsx7(Box7, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsxs7(Box7, { gap: 2, children: [
+      /* @__PURE__ */ jsx7(Text7, { color: "red", bold: true, children: "[d] Delete for real" }),
+      /* @__PURE__ */ jsx7(Text7, { color: "gray", children: "[q] Quit" })
+    ] }) }),
+    isDryRun && summary.successful === 0 && /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { color: "gray", dimColor: true, children: "Press any key to exit" }) }),
+    summary.failed > 0 && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx7(Text7, { color: "red", children: "Failed branches:" }),
+      /* @__PURE__ */ jsxs7(Box7, { marginLeft: 2, flexDirection: "column", children: [
+        summary.results.filter((r) => !r.success).slice(0, 5).map((result) => /* @__PURE__ */ jsxs7(Text7, { color: "red", children: [
+          "- ",
+          result.branch.name,
+          ": ",
+          result.error
+        ] }, result.branch.name)),
+        summary.results.filter((r) => !r.success).length > 5 && /* @__PURE__ */ jsxs7(Text7, { color: "gray", dimColor: true, children: [
+          "... and ",
+          summary.results.filter((r) => !r.success).length - 5,
+          " more"
+        ] })
+      ] })
+    ] }),
+    !isDryRun && /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { color: "gray", dimColor: true, children: "Press any key to exit" }) })
+  ] });
+}
+
+// src/hooks/useWizard.ts
+import { useState as useState4, useCallback } from "react";
+var STEP_ORDER = [
+  "init",
+  "scope",
+  "criteria",
+  "loading",
+  "select",
+  "confirm",
+  "execute",
+  "summary"
+];
+function useWizard(initialStep = "init") {
+  const [step, setStep] = useState4(initialStep);
+  const nextStep = useCallback(() => {
+    const currentIndex = STEP_ORDER.indexOf(step);
+    if (currentIndex < STEP_ORDER.length - 1) {
+      setStep(STEP_ORDER[currentIndex + 1]);
+    }
+  }, [step]);
+  const prevStep = useCallback(() => {
+    const currentIndex = STEP_ORDER.indexOf(step);
+    if (currentIndex > 0) {
+      setStep(STEP_ORDER[currentIndex - 1]);
+    }
+  }, [step]);
+  const goToStep = useCallback((newStep) => {
+    setStep(newStep);
+  }, []);
+  return {
+    step,
+    nextStep,
+    prevStep,
+    goToStep
+  };
+}
+
+// src/services/github.ts
+import { Octokit } from "@octokit/rest";
+var octokit = null;
+function initGitHub(token) {
+  const authToken = token || process.env.GITHUB_TOKEN;
+  octokit = new Octokit({
+    auth: authToken
+  });
+  return octokit;
+}
+async function getDefaultBranch(owner, repo) {
+  if (!octokit) {
+    return "main";
+  }
+  try {
+    const { data } = await octokit.repos.get({ owner, repo });
+    return data.default_branch;
+  } catch (error) {
+    console.error("Error fetching default branch:", error);
+    return "main";
+  }
+}
+
+// src/services/branch-analyzer.ts
+async function fetchBranches(scope, defaultBranch, currentBranch) {
+  let branches = [];
+  if (scope === "local" || scope === "both") {
+    const localBranches = await getLocalBranches(defaultBranch, currentBranch);
+    branches = [...branches, ...localBranches];
+  }
+  if (scope === "remote" || scope === "both") {
+    const remoteBranches = await getRemoteBranches(defaultBranch);
+    if (scope === "both") {
+      for (const remoteBranch of remoteBranches) {
+        const existingIndex = branches.findIndex(
+          (b) => b.name === remoteBranch.name
+        );
+        if (existingIndex >= 0) {
+          branches[existingIndex].isRemote = true;
+        } else {
+          branches.push(remoteBranch);
+        }
+      }
+    } else {
+      branches = remoteBranches;
+    }
+  }
+  return branches;
+}
+function filterBranches(branches, filters) {
+  let filtered = [...branches];
+  filtered = filtered.filter((b) => !b.isProtected && !b.isCurrentBranch);
+  const hasFilters = filters.merged || filters.stale || filters.pattern || filters.age;
+  if (!hasFilters) {
+    return filtered;
+  }
+  filtered = filtered.filter((branch) => {
+    const matches = [];
+    if (filters.merged) {
+      matches.push(branch.isMerged);
+    }
+    if (filters.stale) {
+      matches.push(isOlderThan(branch.lastCommitDate, filters.staleDays));
+    }
+    if (filters.age) {
+      matches.push(isOlderThan(branch.lastCommitDate, filters.ageDays));
+    }
+    if (filters.pattern && filters.patternValue) {
+      matches.push(matchesPattern(branch.name, filters.patternValue));
+    }
+    return matches.some((m) => m === true);
+  });
+  return filtered;
+}
+function matchesPattern(branchName, pattern) {
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`, "i");
+  return regex.test(branchName);
+}
+
+// src/app.tsx
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function App({ options: options2 }) {
+  const { step, goToStep } = useWizard("init");
+  const [repoInfo, setRepoInfo] = useState5(null);
+  const [scope, setScope] = useState5("both");
+  const [filters, setFilters] = useState5({
+    merged: false,
+    stale: false,
+    staleDays: DEFAULT_STALE_DAYS,
+    pattern: false,
+    patternValue: "",
+    age: false,
+    ageDays: DEFAULT_AGE_DAYS
+  });
+  const [allBranches, setAllBranches] = useState5([]);
+  const [filteredBranches, setFilteredBranches] = useState5([]);
+  const [selectedBranches, setSelectedBranches] = useState5([]);
+  const [deletionSummary, setDeletionSummary] = useState5(null);
+  const [error, setError] = useState5(null);
+  const [loadingMessage, setLoadingMessage] = useState5("Initializing...");
+  const [executeForReal, setExecuteForReal] = useState5(false);
+  useEffect2(() => {
+    const initialize = async () => {
+      try {
+        initGit();
+        const isRepo = await isGitRepo();
+        if (!isRepo) {
+          setError("Not a git repository. Please run this command in a git repository.");
+          return;
+        }
+        if (options2.token || process.env.GITHUB_TOKEN) {
+          initGitHub(options2.token);
+        }
+        setLoadingMessage("Detecting repository...");
+        let info = await getRepoInfo();
+        if (info?.isGitHub && (options2.token || process.env.GITHUB_TOKEN)) {
+          setLoadingMessage("Fetching repository info from GitHub...");
+          const defaultBranch = await getDefaultBranch(info.owner, info.repo);
+          info = { ...info, defaultBranch };
+        }
+        setRepoInfo(info);
+        goToStep("scope");
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Unknown error occurred");
+      }
+    };
+    initialize();
+  }, [options2.token, goToStep]);
+  const handleScopeSelect = useCallback2((selectedScope) => {
+    setScope(selectedScope);
+    goToStep("criteria");
+  }, [goToStep]);
+  const handleCriteriaSelect = useCallback2(async (selectedFilters) => {
+    setFilters(selectedFilters);
+    goToStep("loading");
+    setLoadingMessage("Fetching branches...");
+    try {
+      if (!repoInfo) {
+        throw new Error("Repository info not available");
+      }
+      const branches = await fetchBranches(
+        scope,
+        repoInfo.defaultBranch,
+        repoInfo.currentBranch
+      );
+      setAllBranches(branches);
+      setLoadingMessage("Analyzing branches...");
+      const filtered = filterBranches(branches, selectedFilters);
+      setFilteredBranches(filtered);
+      goToStep("select");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to fetch branches");
+    }
+  }, [repoInfo, scope, goToStep]);
+  const handleBranchSelect = useCallback2((selected) => {
+    setSelectedBranches(selected);
+    goToStep("confirm");
+  }, [goToStep]);
+  const handleConfirm = useCallback2(() => {
+    goToStep("execute");
+  }, [goToStep]);
+  const handleDeletionComplete = useCallback2((summary) => {
+    setDeletionSummary(summary);
+    goToStep("summary");
+  }, [goToStep]);
+  const handleDeleteForReal = useCallback2(() => {
+    setExecuteForReal(true);
+    setDeletionSummary(null);
+    goToStep("execute");
+  }, [goToStep]);
+  const handleBack = useCallback2(() => {
+    switch (step) {
+      case "criteria":
+        goToStep("scope");
+        break;
+      case "select":
+        goToStep("criteria");
+        break;
+      case "confirm":
+        goToStep("select");
+        break;
+      default:
+        break;
+    }
+  }, [step, goToStep]);
+  if (error) {
+    return /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsxs8(Text8, { color: "red", bold: true, children: [
+      "Error: ",
+      error
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx8(Header, { repoInfo }),
+    step === "init" && /* @__PURE__ */ jsx8(Box8, { gap: 1, children: /* @__PURE__ */ jsx8(Spinner2, { label: loadingMessage }) }),
+    step === "loading" && /* @__PURE__ */ jsx8(Box8, { gap: 1, children: /* @__PURE__ */ jsx8(Spinner2, { label: loadingMessage }) }),
+    step === "scope" && /* @__PURE__ */ jsx8(ScopeStep, { onSelect: handleScopeSelect }),
+    step === "criteria" && /* @__PURE__ */ jsx8(CriteriaStep, { onSelect: handleCriteriaSelect, onBack: handleBack }),
+    step === "select" && /* @__PURE__ */ jsx8(
+      BranchSelectStep,
+      {
+        branches: filteredBranches,
+        onSelect: handleBranchSelect,
+        onBack: handleBack
+      }
+    ),
+    step === "confirm" && /* @__PURE__ */ jsx8(
+      ConfirmStep,
+      {
+        branches: selectedBranches,
+        isDryRun: !options2.execute,
+        onConfirm: handleConfirm,
+        onCancel: handleBack
+      }
+    ),
+    step === "execute" && /* @__PURE__ */ jsx8(
+      ExecutionStep,
+      {
+        branches: selectedBranches,
+        isDryRun: !options2.execute && !executeForReal,
+        onComplete: handleDeletionComplete
+      }
+    ),
+    step === "summary" && deletionSummary && /* @__PURE__ */ jsx8(
+      SummaryStep,
+      {
+        summary: deletionSummary,
+        isDryRun: !options2.execute && !executeForReal,
+        onDeleteForReal: handleDeleteForReal
+      }
+    )
+  ] });
+}
+
+// src/cli.ts
+import { Command } from "commander";
+function createCLI() {
+  const program = new Command();
+  program.name("git-tidy").description("Interactive CLI tool for cleaning up unused git branches").version("1.0.0").option("-x, --execute", "Actually delete branches (default: dry-run mode)", false).option("-y, --yes", "Skip all confirmations (for scripting)", false).option("-t, --token <token>", "GitHub personal access token (or use GITHUB_TOKEN env)").parse();
+  const opts = program.opts();
+  return {
+    execute: opts.execute || false,
+    yes: opts.yes || false,
+    token: opts.token
+  };
+}
+
+// src/index.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var options = createCLI();
+render(/* @__PURE__ */ jsx9(App, { options }));
+//# sourceMappingURL=index.js.map