@errhythm/gitmux 1.6.2

package/src/commands/switch.js

@@ -0,0 +1,296 @@
+import { basename } from "path";
+import chalk from "chalk";
+import boxen from "boxen";
+import { select } from "@inquirer/prompts";
+import { Listr } from "listr2";
+
+import { getCurrentBranch, getRepoStatus } from "../git/core.js";
+import { listMatchingBranches } from "../git/branches.js";
+import { execAsync, extractMsg } from "../utils/exec.js";
+import { MAX_JOBS } from "../constants.js";
+import { p, THEME } from "../ui/theme.js";
+import { colorBranch } from "../ui/colors.js";
+
+export async function cmdSwitch(repos, {
+  targetBranch, pullChanges, fuzzyMode, createBranch, autoStash, doFetch, dryRun,
+}) {
+  const badges = [];
+  if (pullChanges)  badges.push(p.teal("↓ pull"));
+  if (fuzzyMode)    badges.push(p.purple("~ fuzzy"));
+  if (createBranch) badges.push(p.cyan("+ create"));
+  if (autoStash)    badges.push(p.yellow("⊙ stash"));
+  if (doFetch)      badges.push(p.cyan("↺ fetch"));
+  if (dryRun)       badges.push(p.orange("◎ dry-run"));
+
+  console.log(
+    boxen(
+      p.muted("branch") + "  " + chalk.bold(p.cyan(targetBranch)) +
+      "   " + p.muted("repos") + "  " + chalk.bold(p.white(String(repos.length))) +
+      (badges.length ? "   " + p.slate("·") + "   " + badges.join("  ") : ""),
+      {
+        padding: { top: 0, bottom: 0, left: 2, right: 2 },
+        borderStyle: "round",
+        borderColor: "#334155",
+      },
+    ),
+  );
+  console.log();
+
+  let resolvedBranches = repos.map(() => targetBranch);
+
+  if (fuzzyMode) {
+    console.log(
+      p.muted(`  Resolving "${targetBranch}" across ${repos.length} repo${repos.length !== 1 ? "s" : ""}…\n`),
+    );
+
+    for (let i = 0; i < repos.length; i++) {
+      const name       = basename(repos[i]);
+      const candidates = listMatchingBranches(repos[i], targetBranch);
+
+      if (candidates.length === 0) {
+        resolvedBranches[i] = null;
+      } else if (candidates.length === 1) {
+        resolvedBranches[i] = candidates[0];
+      } else {
+        resolvedBranches[i] = await select({
+          message: chalk.bold(p.white(name)) + p.muted(` — pick branch for "${targetBranch}":`),
+          choices: candidates.map((c) => ({ value: c, name: p.cyan(c) })),
+          theme:   THEME,
+        });
+      }
+    }
+    console.log();
+  }
+
+  const stats      = { ok: 0, pulled: 0, skip: 0, fail: 0, stashed: 0, alreadyOn: 0 };
+  const failedRepos = [];
+  const timings    = [];
+  const startAll   = Date.now();
+  const numWidth   = String(repos.length).length;
+
+  // ── Phase 1: parallel pre-fetch ───────────────────────────────────────────
+  // Fire all fetches concurrently so network latency is paid once (max 1 fetch
+  // time) rather than once per Listr slot. Silent — no Listr overhead.
+  if (!dryRun) {
+    console.log("  " + p.muted(`Pre-fetching ${repos.length} repos in parallel…`));
+    // Track which repos fetched successfully so phase 2 knows
+    const fetchedSet = new Set();
+    await Promise.all(
+      repos.map(async (repo, i) => {
+        const branch = resolvedBranches[i];
+        if (!branch) return;
+        try {
+          await execAsync(`git fetch origin "${branch}"`, { cwd: repo });
+          fetchedSet.add(repo);
+        } catch {
+          // Branch may not exist on remote — phase 2 will handle it gracefully
+        }
+      }),
+    );
+    // Overwrite the line once done
+    process.stdout.write("\x1b[1A\x1b[2K");
+
+    // ── Phase 2: switch + pull ────────────────────────────────────────────────
+    const tasks = new Listr(
+      repos.map((repo, i) => {
+        const name   = basename(repo);
+        const branch = resolvedBranches[i];
+        const idx    = p.muted(`[${String(i + 1).padStart(numWidth)}/${repos.length}]`);
+
+        return {
+          title: idx + "  " + chalk.bold(p.white(name)) + p.muted("  waiting…"),
+          skip:  () => (branch === null ? "no matching branch" : false),
+          task:  async (_, task) => {
+            const t0      = Date.now();
+            const elapsed = () => p.muted("  " + ((Date.now() - t0) / 1000).toFixed(1) + "s");
+            const current = await getCurrentBranch(repo);
+
+            task.title =
+              idx + "  " + chalk.bold(p.white(name)) + "  " +
+              p.muted(current + " → ") + p.cyan(branch) + p.muted("  …");
+
+            if (current === branch && !pullChanges) {
+              stats.ok++;
+              stats.alreadyOn++;
+              timings.push((Date.now() - t0) / 1000);
+              task.title =
+                idx + "  " + chalk.bold(p.white(name)) +
+                "  " + p.teal("◉") + "  " + colorBranch(branch) +
+                p.muted("  already on branch") + elapsed();
+              return;
+            }
+
+            let stashed = false;
+            const { dirty } = autoStash ? await getRepoStatus(repo) : { dirty: false };
+            if (dirty) {
+              try {
+                await execAsync("git stash push --include-untracked -m 'gitmux auto-stash'", { cwd: repo });
+                stashed = true;
+                stats.stashed++;
+              } catch {}
+            }
+
+            if (doFetch) {
+              try { await execAsync("git fetch --all --prune", { cwd: repo }); } catch {}
+            }
+
+            if (current !== branch) {
+              try {
+                if (createBranch) {
+                  try {
+                    await execAsync(`git switch "${branch}"`, { cwd: repo });
+                  } catch {
+                    await execAsync(`git switch -c "${branch}"`, { cwd: repo });
+                  }
+                } else {
+                  await execAsync(`git switch "${branch}"`, { cwd: repo });
+                }
+              } catch (e) {
+                const msg = extractMsg(e);
+                if (stashed) {
+                  try { await execAsync("git stash pop", { cwd: repo }); } catch {}
+                }
+                if (/did not match|pathspec|not found|invalid reference/i.test(msg)) {
+                  stats.skip++;
+                  timings.push((Date.now() - t0) / 1000);
+                  task.title =
+                    idx + "  " + chalk.bold(p.white(name)) +
+                    "  " + p.yellow("⊘") + "  " + p.muted("branch not found") + elapsed();
+                  return;
+                }
+                stats.fail++;
+                failedRepos.push({ name, msg });
+                timings.push((Date.now() - t0) / 1000);
+                task.title =
+                  idx + "  " + chalk.bold(p.white(name)) +
+                  "  " + p.red("✘") + "  " + p.muted(msg.slice(0, 60)) + elapsed();
+                throw new Error(msg);
+              }
+            }
+
+            let pulled = false;
+            if (pullChanges) {
+              try {
+                await execAsync("git pull", { cwd: repo });
+                pulled = true;
+              } catch (e) {
+                failedRepos.push({ name, msg: "pull failed: " + extractMsg(e) });
+              }
+            }
+
+            if (stashed) {
+              try { await execAsync("git stash pop", { cwd: repo }); } catch {}
+            }
+
+            stats.ok++;
+            if (pulled) stats.pulled++;
+            timings.push((Date.now() - t0) / 1000);
+
+            const tags = [];
+            if (pulled)  tags.push(p.teal("↓ pulled"));
+            if (stashed) tags.push(p.yellow("⊙ stashed"));
+            if (dryRun)  tags.push(p.orange("◎ dry"));
+
+            const transitionLabel = current === branch
+              ? colorBranch(branch)
+              : p.muted(current + " → ") + colorBranch(branch);
+
+            task.title =
+              idx + "  " + chalk.bold(p.white(name)) +
+              "  " + p.green("✔") + "  " + transitionLabel +
+              (tags.length ? "  " + tags.join("  ") : "") +
+              elapsed();
+          },
+        };
+      }),
+      {
+        concurrent:      MAX_JOBS,
+        exitOnError:     false,
+        rendererOptions: { collapseSkips: false, collapseErrors: false },
+      },
+    );
+
+    await tasks.run().catch(() => {});
+  } else {
+    // dry-run: skip fetch phase, just run the Listr switch tasks
+    const tasks = new Listr(
+      repos.map((repo, i) => {
+        const name   = basename(repo);
+        const branch = resolvedBranches[i];
+        const idx    = p.muted(`[${String(i + 1).padStart(numWidth)}/${repos.length}]`);
+        return {
+          title: idx + "  " + chalk.bold(p.white(name)) + p.muted("  waiting…"),
+          skip:  () => (branch === null ? "no matching branch" : false),
+          task:  async (_, task) => {
+            const t0      = Date.now();
+            const elapsed = () => p.muted("  " + ((Date.now() - t0) / 1000).toFixed(1) + "s");
+            const current = await getCurrentBranch(repo);
+            stats.ok++;
+            timings.push((Date.now() - t0) / 1000);
+            task.title =
+              idx + "  " + chalk.bold(p.white(name)) +
+              "  " + p.orange("◎") + "  " + p.muted(current + " → ") + colorBranch(branch) +
+              p.muted("  dry-run") + elapsed();
+          },
+        };
+      }),
+      {
+        concurrent:      MAX_JOBS,
+        exitOnError:     false,
+        rendererOptions: { collapseSkips: false, collapseErrors: false },
+      },
+    );
+    await tasks.run().catch(() => {});
+  }
+
+  for (const b of resolvedBranches) {
+    if (b === null) stats.skip++;
+  }
+
+  console.log();
+
+  const totalElapsed = ((Date.now() - startAll) / 1000).toFixed(1);
+  const avgTime = timings.length
+    ? (timings.reduce((s, t) => s + t, 0) / timings.length).toFixed(1)
+    : "0.0";
+
+  const sep          = p.slate("   ·   ");
+  const summaryParts = [];
+  if (stats.ok > 0)      summaryParts.push(chalk.bold(p.green(`✔  ${stats.ok} switched`)));
+  if (stats.pulled > 0)  summaryParts.push(p.teal(`↓  ${stats.pulled} pulled`));
+  if (stats.stashed > 0) summaryParts.push(p.yellow(`⊙  ${stats.stashed} stashed`));
+  if (stats.skip > 0)    summaryParts.push(p.yellow(`⊘  ${stats.skip} skipped`));
+  if (stats.fail > 0)    summaryParts.push(p.red(`✘  ${stats.fail} failed`));
+  if (dryRun)            summaryParts.push(p.orange("◎  dry-run · no changes made"));
+
+  console.log(
+    boxen(
+      summaryParts.join(sep) +
+      "\n" + p.muted(`${totalElapsed}s total · avg ${avgTime}s/repo · ${repos.length} repos`),
+      {
+        padding: { top: 0, bottom: 0, left: 2, right: 2 },
+        borderStyle: "round",
+        borderColor:
+          stats.fail > 0 ? "#f87171" :
+          stats.ok === 0 ? "#fbbf24" :
+                           "#4ade80",
+      },
+    ),
+  );
+  console.log();
+
+  if (failedRepos.length > 0) {
+    console.log("  " + chalk.bold(p.white("Errors")));
+    console.log("  " + p.dim("─".repeat(50)));
+    for (const { name, msg } of failedRepos) {
+      console.log(
+        "  " + p.red("✘") + " " +
+        chalk.bold(p.white(name)) + "  " +
+        p.muted(msg.slice(0, 90)),
+      );
+    }
+    console.log();
+  }
+
+  return stats.fail > 0 ? 1 : 0;
+}

package/src/config/index.js

@@ -0,0 +1,22 @@
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+
+export const CONFIG_PATH = join(homedir(), ".config", "gitmux", "gitmux.json");
+
+export function loadConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+export function saveConfig(config) {
+  try {
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf8");
+  } catch (e) {
+    process.stderr.write(`gitmux: warning: could not save config: ${e.message}\n`);
+  }
+}

package/src/constants.js

@@ -0,0 +1,15 @@
+import { cpus } from "os";
+import { readFileSync } from "fs";
+
+const pkgPath = new URL("../package.json", import.meta.url).pathname;
+let VERSION = "1.6.0";
+try {
+  VERSION = JSON.parse(readFileSync(pkgPath, "utf8")).version;
+} catch (e) {
+  console.error("Failed to read version:", e);
+}
+
+export { VERSION };
+export const MAX_JOBS = cpus().length;
+export const DEFAULT_DEPTH = 4;
+export const SUBCOMMANDS = new Set(["status", "fetch", "mr", "portal", "settings", "about"]);

package/src/git/branches.js

@@ -0,0 +1,68 @@
+import { execSync } from "child_process";
+
+export function listMatchingBranches(repoPath, partial) {
+  try {
+    const out = execSync(`git branch -a --list "*${partial}*"`, {
+      cwd: repoPath,
+      encoding: "utf8",
+    });
+    return [
+      ...new Set(
+        out
+          .trim()
+          .split("\n")
+          .map((b) =>
+            b
+              .trim()
+              .replace(/^\*\s*/, "")
+              .replace(/^remotes\/[^/]+\//, ""),
+          )
+          .filter(Boolean)
+          .filter((b) => !b.includes("HEAD")),
+      ),
+    ];
+  } catch {
+    return [];
+  }
+}
+
+export function listRecentBranches(repoPath) {
+  try {
+    const out = execSync(
+      'git for-each-ref --sort=-committerdate --format="%(refname:short)\t%(committerdate:unix)" refs/heads refs/remotes/origin',
+      { cwd: repoPath, encoding: "utf8" },
+    );
+    return out
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => {
+        const [rawName, rawTs] = line.split("\t");
+        const name = rawName.replace(/^origin\//, "");
+        return { name, ts: Number(rawTs) || 0 };
+      })
+      .filter((branch) => branch.name && branch.name !== "HEAD");
+  } catch {
+    return [];
+  }
+}
+
+export function getBranchChoices(repos) {
+  const branchMap = new Map();
+
+  for (const repo of repos) {
+    for (const branch of listRecentBranches(repo.repo)) {
+      const existing = branchMap.get(branch.name);
+      if (!existing) {
+        branchMap.set(branch.name, { ...branch, repos: [repo.name] });
+        continue;
+      }
+      existing.ts = Math.max(existing.ts, branch.ts);
+      if (!existing.repos.includes(repo.name)) {
+        existing.repos.push(repo.name);
+      }
+    }
+  }
+
+  return [...branchMap.values()].sort((a, b) => b.ts - a.ts);
+}

package/src/git/core.js

@@ -0,0 +1,67 @@
+import { execSync } from "child_process";
+import { join, dirname } from "path";
+
+import { execAsync } from "../utils/exec.js";
+
+export function findRepos(cwd, depth) {
+  try {
+    const out = execSync(
+      `find . -mindepth 1 -maxdepth ${depth} -type d -name '.git' 2>/dev/null`,
+      { cwd, encoding: "utf8" },
+    );
+    const repos = out
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((g) => join(cwd, dirname(g)));
+
+    // Filter out repos nested inside another found repo (submodule / monorepo protection).
+    // A repo is nested if any other repo path is a strict path prefix of it.
+    return repos.filter(
+      (repo) => !repos.some(
+        (other) => other !== repo && repo.startsWith(other + "/"),
+      ),
+    );
+  } catch {
+    return [];
+  }
+}
+
+export async function getCurrentBranch(repoPath) {
+  try {
+    const { stdout } = await execAsync("git rev-parse --abbrev-ref HEAD", {
+      cwd: repoPath,
+      encoding: "utf8",
+    });
+    return stdout.trim();
+  } catch {
+    return "unknown";
+  }
+}
+
+export async function getRepoStatus(repoPath) {
+  try {
+    const { stdout } = await execAsync("git status --porcelain", {
+      cwd: repoPath,
+      encoding: "utf8",
+    });
+    const lines = stdout.trim().split("\n").filter(Boolean);
+    return { dirty: lines.length > 0, count: lines.length };
+  } catch {
+    return { dirty: false, count: 0 };
+  }
+}
+
+export async function getAheadBehind(repoPath) {
+  try {
+    const { stdout } = await execAsync(
+      "git rev-list --left-right --count @{upstream}...HEAD 2>/dev/null",
+      { cwd: repoPath, encoding: "utf8" },
+    );
+    if (!stdout.trim()) return { ahead: 0, behind: 0 };
+    const [behind, ahead] = stdout.trim().split("\t").map(Number);
+    return { ahead: ahead || 0, behind: behind || 0 };
+  } catch {
+    return { ahead: 0, behind: 0 };
+  }
+}

package/src/git/templates.js

@@ -0,0 +1,51 @@
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+
+function getWeekOfMonth(date) {
+  return Math.floor((date.getDate() - 1) / 7) + 1;
+}
+
+function getIsoWeek(date) {
+  const copy = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const day = copy.getUTCDay() || 7;
+  copy.setUTCDate(copy.getUTCDate() + 4 - day);
+  const yearStart = new Date(Date.UTC(copy.getUTCFullYear(), 0, 1));
+  return Math.ceil((((copy - yearStart) / 86400000) + 1) / 7);
+}
+
+export function expandBranchTemplate(template, date = new Date()) {
+  const month = date.getMonth() + 1;
+  const day   = date.getDate();
+  const values = {
+    yyyy: String(date.getFullYear()),
+    yy:   String(date.getFullYear()).slice(-2),
+    mm:   pad2(month),
+    m:    String(month),
+    dd:   pad2(day),
+    d:    String(day),
+    q:    String(Math.floor((month - 1) / 3) + 1),
+    w:    String(getWeekOfMonth(date)),
+    ww:   pad2(getIsoWeek(date)),
+  };
+  return template.replace(/\{([a-z]+)\}/gi, (match, token) => values[token] ?? match);
+}
+
+export function getSwitchBranchSuggestions(config, date = new Date()) {
+  const templates = config.switch?.branchSuggestions;
+  if (!Array.isArray(templates)) return [];
+
+  const seen = new Set();
+
+  return templates
+    .filter((t) => typeof t === "string")
+    .map((t) => t.trim())
+    .filter(Boolean)
+    .map((t) => ({ template: t, value: expandBranchTemplate(t, date).trim() }))
+    .filter((item) => item.value !== "")
+    .filter((item) => {
+      if (seen.has(item.value)) return false;
+      seen.add(item.value);
+      return true;
+    });
+}

package/src/gitlab/api.js

@@ -0,0 +1,46 @@
+import { execFileAsync, extractMsg } from "../utils/exec.js";
+
+const DEBUG = () => process.env.GITMUX_DEBUG === "1";
+
+function dbg(label, value) {
+  if (!DEBUG()) return;
+  process.stderr.write(
+    `\n\x1b[35m[gitmux:debug] ${label}\x1b[0m\n${typeof value === "string" ? value : JSON.stringify(value, null, 2)
+    }\n`,
+  );
+}
+
+export async function glabApi(apiPath, { method = "GET", fields = {} } = {}) {
+  const args = ["api", apiPath, "-X", method];
+  for (const [k, v] of Object.entries(fields)) args.push("-F", `${k}=${v}`);
+  dbg("glab " + args.join(" "), "");
+  try {
+    const { stdout } = await execFileAsync("glab", args);
+    const parsed = JSON.parse(stdout);
+    dbg("response", parsed);
+    return parsed;
+  } catch (e) {
+    dbg("ERROR stdout", e.stdout ?? "");
+    dbg("ERROR stderr", e.stderr ?? "");
+    dbg("ERROR message", e.message ?? "");
+    throw new Error(extractMsg(e));
+  }
+}
+
+export async function glabGraphQL(query) {
+  dbg("graphql query", query);
+  try {
+    const { stdout } = await execFileAsync("glab", ["api", "graphql", "-f", `query=${query}`]);
+    const result = JSON.parse(stdout);
+    dbg("graphql response", result);
+    if (result.errors?.length) {
+      throw new Error(result.errors.map((e) => e.message).join("; "));
+    }
+    return result.data;
+  } catch (e) {
+    dbg("ERROR stdout", e.stdout ?? "");
+    dbg("ERROR stderr", e.stderr ?? "");
+    dbg("ERROR message", e.message ?? "");
+    throw new Error(extractMsg(e));
+  }
+}

package/src/gitlab/helpers.js

@@ -0,0 +1,73 @@
+import { execSync } from "child_process";
+
+export function getRemoteUrl(repoPath) {
+  try {
+    return execSync("git remote get-url origin", {
+      cwd: repoPath,
+      encoding: "utf8",
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+export function branchToTitle(branch) {
+  const segment = branch.split("/").pop() ?? branch;
+  return segment
+    .replace(/[-_]+/g, " ")
+    .replace(/^\w/, (c) => c.toUpperCase())
+    .trim();
+}
+
+export function isGitLabRemote(url) {
+  return /gitlab/i.test(url);
+}
+
+export function getDefaultBranch(repoPath) {
+  try {
+    const out = execSync("git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null", {
+      cwd: repoPath,
+      encoding: "utf8",
+    }).trim();
+    return out.replace(/^refs\/remotes\/origin\//, "") || "main";
+  } catch {
+    return "main";
+  }
+}
+
+export function extractGroupFromUrl(url) {
+  const path = url
+    .replace(/^git@[^:]+:/, "")
+    .replace(/^https?:\/\/[^/]+\//, "")
+    .replace(/\.git$/, "");
+  const parts = path.split("/");
+  if (parts.length < 2) return null;
+  return parts.slice(0, -1).join("/");
+}
+
+export function detectGroupFromRepos(repos) {
+  const freq = new Map();
+  for (const repo of repos) {
+    const remote = getRemoteUrl(repo);
+    if (!isGitLabRemote(remote)) continue;
+    const group = extractGroupFromUrl(remote);
+    if (group) freq.set(group, (freq.get(group) ?? 0) + 1);
+  }
+  if (freq.size === 0) return null;
+  return [...freq.entries()].sort((a, b) => b[1] - a[1])[0][0];
+}
+
+export function getProjectPath(url) {
+  return url
+    .replace(/^git@[^:]+:/, "")
+    .replace(/^https?:\/\/[^/]+\//, "")
+    .replace(/\.git$/, "");
+}
+
+export function slugify(str) {
+  return str
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 60);
+}