git-nuke-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Larsen Cundric
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+# git-nuke-cli
+
+> The "I am done with this branch" nuclear option. Deletes local + remote + tracking refs in one command.
+
+## Install
+
+```sh
+npm install -g git-nuke-cli
+```
+
+## Usage
+
+```sh
+# Nuke a specific branch
+git nuke feature-old
+
+# Nuke without confirmation
+git nuke -f stale-branch
+
+# Find and nuke ALL merged branches
+git nuke --merged
+```
+
+### Example output
+
+```
+git nuke feature-old ──────────────────────────────
+
+  Plan:
+    ✗ Delete local branch feature-old
+    ✗ Delete remote branch origin/feature-old
+    ● Prune tracking refs
+
+  ? Proceed? (y/N) y
+
+  ✓ Deleted local branch feature-old
+  ✓ Deleted remote branch origin/feature-old
+  ✓ Pruned tracking refs
+```
+
+### Merged branches cleanup
+
+```
+git nuke --merged ─────────────────────────────────
+
+  Found 3 merged branches:
+
+    ✗ feature/login
+    ✗ fix/typo
+    ✗ chore/deps
+
+  ? Nuke all 3 branches? (y/N) y
+
+  ✓ Deleted local branch feature/login
+  ✓ Deleted local branch fix/typo
+  ✓ Deleted local branch chore/deps
+  ✓ Done. 3 branches nuked.
+```
+
+## Features
+
+- **Shows the plan first**: See exactly what will be deleted before confirming
+- **Deletes everywhere**: Local branch, remote branch, and prunes tracking refs
+- **Merged cleanup**: `--merged` finds all branches already merged into the default branch
+- **Safety first**: Refuses to nuke the current branch, asks for confirmation by default
+- **Force mode**: `-f` skips confirmation for scripting
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "git-nuke-cli",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "The 'I am done with this branch' nuclear option. Delete local + remote + tracking refs.",
+  "bin": {
+    "git-nuke": "./src/cli.js"
+  },
+  "files": [
+    "src/",
+    "README.md"
+  ],
+  "keywords": ["git", "branch", "delete", "cleanup", "cli"],
+  "author": "Larsen Cundric",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/larsencundric/git-nuke-cli.git"
+  },
+  "homepage": "https://github.com/larsencundric/git-nuke-cli#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chalk": "5.6.2",
+    "commander": "14.0.3"
+  }
+}

package/src/cli.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+import { createInterface } from 'node:readline';
+import chalk from 'chalk';
+import { program } from 'commander';
+import { git, gitLines, symbols, header, fatal, isInsideGitRepo, getCurrentBranch, getDefaultBranch } from './utils.js';
+
+program
+  .name('git-nuke')
+  .description('Delete a branch everywhere — local, remote, and tracking refs')
+  .argument('[branch]', 'branch to nuke')
+  .option('-m, --merged', 'find and nuke all fully merged branches')
+  .option('-f, --force', 'skip confirmation prompt')
+  .version('1.0.0')
+  .addHelpText('after', `
+Examples:
+  git nuke feature-old          Delete feature-old locally and remotely
+  git nuke --merged             Nuke all merged branches
+  git nuke -f stale-branch      Nuke without asking`)
+  .action(run);
+
+program.parse();
+
+async function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith('y'));
+    });
+  });
+}
+
+function getBranchInfo(branch) {
+  const current = getCurrentBranch();
+  const isLocal = gitLines(['branch', '--list', branch]).length > 0;
+  let remotes = [];
+  try {
+    const remoteBranches = gitLines(['branch', '-r', '--list', `*/${branch}`]);
+    remotes = remoteBranches.map((r) => r.trim()).filter((r) => r.endsWith('/' + branch));
+  } catch {}
+  return { isLocal, remotes, isCurrent: branch === current };
+}
+
+function getMergedBranches() {
+  const defaultBranch = getDefaultBranch();
+  const current = getCurrentBranch();
+  const protected_ = new Set([defaultBranch, current, 'HEAD'].filter(Boolean));
+  const merged = gitLines(['branch', '--merged', defaultBranch])
+    .map((b) => b.trim().replace(/^\* /, ''))
+    .filter((b) => !protected_.has(b) && b.length > 0);
+  return merged;
+}
+
+async function nukeBranch(branch, { skipConfirm = false, forceDelete = false } = {}) {
+  const info = getBranchInfo(branch);
+  if (info.isCurrent) {
+    fatal(`Cannot nuke the current branch (${branch}). Switch to another branch first.`);
+  }
+  if (!info.isLocal && info.remotes.length === 0) {
+    fatal(`Branch '${branch}' not found locally or on any remote`);
+  }
+
+  console.log(chalk.bold('  Plan:'));
+  if (info.isLocal) {
+    console.log(`    ${chalk.red(symbols.cross)} Delete local branch ${chalk.white(branch)}`);
+  }
+  for (const remote of info.remotes) {
+    console.log(`    ${chalk.red(symbols.cross)} Delete remote branch ${chalk.white(remote)}`);
+  }
+  console.log(`    ${chalk.yellow(symbols.bullet)} Prune tracking refs`);
+  console.log();
+
+  if (!skipConfirm) {
+    const ok = await confirm(`  ${chalk.yellow('?')} Proceed? (y/N) `);
+    if (!ok) {
+      console.log(chalk.dim('  Aborted.'));
+      console.log();
+      return false;
+    }
+  }
+
+  if (info.isLocal) {
+    try {
+      git(['branch', forceDelete ? '-D' : '-d', branch]);
+      console.log(`  ${chalk.green(symbols.check)} Deleted local branch ${chalk.white(branch)}`);
+    } catch (e) {
+      console.log(`  ${chalk.red(symbols.cross)} Failed to delete local branch: ${e.message}`);
+    }
+  }
+
+  for (const remote of info.remotes) {
+    const [remoteName, ...branchParts] = remote.split('/');
+    const remoteBranch = branchParts.join('/');
+    try {
+      git(['push', remoteName, '--delete', remoteBranch]);
+      console.log(`  ${chalk.green(symbols.check)} Deleted remote branch ${chalk.white(remote)}`);
+    } catch (e) {
+      console.log(`  ${chalk.red(symbols.cross)} Failed to delete ${remote}: ${e.stderr || e.message}`);
+    }
+  }
+
+  const prunedRemotes = new Set();
+  for (const remote of info.remotes) {
+    const remoteName = remote.split('/')[0];
+    if (!prunedRemotes.has(remoteName)) {
+      git(['remote', 'prune', remoteName], { allowFail: true });
+      prunedRemotes.add(remoteName);
+    }
+  }
+  if (prunedRemotes.size === 0) {
+    git(['remote', 'prune', 'origin'], { allowFail: true });
+  }
+  console.log(`  ${chalk.green(symbols.check)} Pruned tracking refs`);
+  return true;
+}
+
+async function run(branch, opts) {
+  if (!isInsideGitRepo()) fatal('Not inside a git repository');
+
+  if (opts.merged) {
+    header('git nuke --merged');
+    const merged = getMergedBranches();
+    if (merged.length === 0) {
+      console.log(chalk.dim('  No merged branches to clean up.'));
+      console.log();
+      return;
+    }
+
+    console.log(chalk.bold(`  Found ${merged.length} merged branch${merged.length === 1 ? '' : 'es'}:\n`));
+    for (const b of merged) {
+      console.log(`    ${chalk.red(symbols.cross)} ${b}`);
+    }
+    console.log();
+
+    if (!opts.force) {
+      const ok = await confirm(`  ${chalk.yellow('?')} Nuke all ${merged.length} branches? (y/N) `);
+      if (!ok) {
+        console.log(chalk.dim('  Aborted.'));
+        console.log();
+        return;
+      }
+    }
+
+    console.log();
+    for (const b of merged) {
+      await nukeBranch(b, { skipConfirm: true });
+    }
+    console.log();
+    console.log(`  ${chalk.green(symbols.check)} Done. ${merged.length} branch${merged.length === 1 ? '' : 'es'} nuked.`);
+    console.log();
+  } else {
+    if (!branch) {
+      fatal('Specify a branch name or use --merged');
+    }
+    header(`git nuke ${chalk.white(branch)}`);
+    await nukeBranch(branch, { skipConfirm: opts.force, forceDelete: opts.force });
+    console.log();
+  }
+}

package/src/utils.js

@@ -0,0 +1,71 @@
+import { execFileSync } from 'node:child_process';
+import chalk from 'chalk';
+
+export function git(args, opts = {}) {
+  try {
+    return execFileSync('git', args, {
+      encoding: 'utf-8',
+      maxBuffer: 50 * 1024 * 1024,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      ...opts,
+    }).trim();
+  } catch (e) {
+    if (opts.allowFail) return '';
+    throw e;
+  }
+}
+
+export function gitLines(args, opts = {}) {
+  const out = git(args, opts);
+  return out ? out.split('\n') : [];
+}
+
+export function getCurrentBranch() {
+  const branch = git(['rev-parse', '--abbrev-ref', 'HEAD']);
+  // In detached HEAD state, git returns the literal string "HEAD"
+  return branch === 'HEAD' ? null : branch;
+}
+
+export function getDefaultBranch() {
+  try {
+    const ref = git(['symbolic-ref', 'refs/remotes/origin/HEAD']);
+    return ref.replace('refs/remotes/origin/', '');
+  } catch {
+    for (const name of ['main', 'master']) {
+      try {
+        git(['rev-parse', '--verify', name]);
+        return name;
+      } catch {}
+    }
+    return 'main';
+  }
+}
+
+export function isInsideGitRepo() {
+  try {
+    git(['rev-parse', '--is-inside-work-tree']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export const symbols = {
+  bullet: '●',
+  check: '✓',
+  cross: '✗',
+  warning: '⚠',
+  line: '─',
+};
+
+export function header(text) {
+  // Strip ANSI escape codes so chalk-colored text doesn't skew the padding
+  const plainLength = text.replace(/\u001b\[[0-9;]*[a-zA-Z]/g, '').length;
+  const line = symbols.line.repeat(Math.max(0, 50 - plainLength));
+  console.log(`\n${chalk.bold.cyan(text)} ${chalk.dim(line)}\n`);
+}
+
+export function fatal(msg) {
+  console.error(`${chalk.red(symbols.cross)} ${msg}`);
+  process.exit(1);
+}