avil13-co 2.2.5 → 2.3.0

package/src/commands/delete-barnch.ts

@@ -1,31 +1,38 @@
-import inquirer from 'inquirer';
+import { prompt } from '../prompt';
 import { exec } from './exec';
-import { clc } from '../color';
+import { print } from '../terminal';
 
-export async function deleteBranch(branchName: string) {
-  if (!branchName) {
-    throw new Error('No branch...');
+export async function deleteBranches(branchNames: string[], confirm = true, force = true) {
+  const branches = [...new Set(branchNames)];
+  if (!branches.length || branches.some(branch => !branch)) {
+    throw new Error('No branches selected.');
   }
 
-  const res = await inquirer.prompt({
-    type: 'confirm',
-    name: 'answer',
-    message: clc.yellow('Are you sure you want to delete the branch "') + clc.red(branchName) + clc.yellow('"?'),
-    default: false,
-  });
-
-  if (res.answer === true) {
-    const command = `git branch -D ${branchName}`;
-
-    console.log(' ' + clc.redBg(`git branch -D ${branchName}`, '') + '\n');
-
-    const checkoutCommandResult = await exec(command);
-
-    console.log(checkoutCommandResult);
-    console.log(clc.yellow('Branch'), clc.red(branchName), clc.yellow('has been deleted'));
+  if (confirm) {
+    const { answer } = await prompt({
+      type: 'confirm',
+      name: 'answer',
+      message: 'Delete these branches: ' + branches.join(', ') + '?',
+      default: false,
+    });
+    if (!answer) {
+      print('Branches were not deleted.');
+      return;
+    }
+  }
 
-    return;
+  // Attempt every selected branch and report partial failures as well.
+  const errors: string[] = [];
+  for (const branch of branches) {
+    try {
+      print(await exec(['branch', force ? '-D' : '-d', '--', branch]));
+    } catch (error) {
+      errors.push(branch + ': ' + (error instanceof Error ? error.message : String(error)));
+    }
   }
+  if (errors.length) throw new Error(errors.join('\n'));
+}
 
-  console.log(clc.yellow('The branch was not deleted'));
+export async function deleteBranch(branchName: string) {
+  return deleteBranches([branchName]);
 }

package/src/commands/exec.ts

@@ -1,9 +1,13 @@
-import { exec as exe } from 'child_process';
+import { execFile } from 'child_process';
 
-export function exec(command): Promise<string> {
-  return new Promise((resolve, reject) =>
-    exe(command, (err, stdout) =>
-      err ? reject(err) : resolve(stdout)
-    )
-  );
+export function exec(args: string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile('git', args, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error([stderr.trim(), stdout.trim()].filter(Boolean).join('\n') || error.message));
+      } else {
+        resolve([stdout.trimEnd(), stderr.trimEnd()].filter(Boolean).join('\n'));
+      }
+    });
+  });
 }

package/src/commands/get-branches.ts

@@ -1,50 +1,24 @@
 import { exec } from './exec';
 
-
 export enum BranchesType {
   All,
   Merged,
   NotMerged,
 }
 
-const commandsForGetBranches = {
-  [BranchesType.All]: 'git branch --all',
-  [BranchesType.Merged]: 'git branch --all --merged',
-  [BranchesType.NotMerged]: 'git branch --all --no-merged',
-} as const;
-
-/**
- * get branch list
- */
-export function getBranches(type: BranchesType): Promise<string[]> {
-  const command = commandsForGetBranches[type];
-
-  return exec(command)
-    .then(parseBranches)
-    .then(branches => {
-      if (branches.length) {
-        return branches;
-      }
-      throw new Error('No branches found...');
-    });
-}
-
-function parseBranches(stdout) {
-  return stdout
-    .split('\n')
-    .filter(s => !/\s->\s/.test(s))
-    .map(cleanBranchName)
-    .filter(Boolean)
-    .filter(onlyUnique);
-}
-
-function cleanBranchName(name) {
-  return name
-    .replace(/^\*/, '')
-    .replace(/remotes\/origin\//, '')
-    .trim();
-}
-
-function onlyUnique(value, index, self) {
-  return self.indexOf(value) === index;
+/** Remote origin refs are also offered for checkout/merge; deletion is local only. */
+export async function getBranches(type: BranchesType, localOnly = false): Promise<string[]> {
+  const args = ['branch', '--format=%(refname)'];
+  if (!localOnly) args.push('--all');
+  if (type === BranchesType.Merged) args.push('--merged');
+  if (type === BranchesType.NotMerged) args.push('--no-merged');
+
+  const stdout = await exec(args);
+  const branches = [...new Set(stdout.split('\n')
+    .map(name => name.trim())
+    .filter(name => name && !/^refs\/remotes\/.+\/HEAD$/.test(name))
+    .map(name => name.replace(/^refs\/heads\//, '')
+      .replace(/^refs\/remotes\/(?:origin\/)?/, '')))];
+  if (!branches.length) throw new Error('No branches found.');
+  return branches;
 }

package/src/commands/get-current-branch-name.ts

@@ -1,9 +1,5 @@
 import { exec } from './exec';
 
-export async function getCurrentBranchName(){
-  const currentBranchName = `git rev-parse --abbrev-ref HEAD`;
-
-  const stdout = await exec(currentBranchName);
-  console.log(stdout);
+export async function getCurrentBranchName(): Promise<string> {
+  return (await exec(['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
 }
-

package/src/commands/merge-branch.ts

@@ -1,46 +1,37 @@
 import { exec } from './exec';
-import { clc } from '../color';
-import inquirer from 'inquirer';
+import { getCurrentBranchName } from './get-current-branch-name';
+import { deleteBranches } from './delete-barnch';
+import { print } from '../terminal';
+import { prompt } from '../prompt';
 
-//
 export async function mergeBranch(branchName: string) {
-  if (!branchName) {
-    throw new Error('No branch...');
-  }
-
-  const currentBranch = await exec('git rev-parse --abbrev-ref HEAD');
-
-  const message = [
-    clc._blue,
-    'Do you want to merge branch ',
-    clc._green,
-    branchName, // branch
-    clc._blue,
-    ' into ',
-    clc._green,
-    currentBranch, // branch
-    clc._blue,
-    '?',
-    clc._off,
-  ].join('');
+  if (!branchName) throw new Error('No branch selected.');
+  const currentBranch = await getCurrentBranchName();
+  if (branchName === currentBranch) throw new Error('Cannot merge the current branch into itself.');
 
-  const res = await inquirer.prompt({
+  const { answer } = await prompt({
     type: 'confirm',
     name: 'answer',
-    message,
+    message: 'Merge branch ' + branchName + ' into ' + currentBranch + '?',
     default: false,
   });
-
-  if (res.answer === true) {
-    const checkoutCommand = `git merge ${branchName}`;
-
-    console.log(' ' + clc.green('git merge', branchName) + '\n');
-
-    const checkoutCommandResult = await exec(checkoutCommand);
-    console.log(checkoutCommandResult);
-
+  if (!answer) {
+    print('Branch was not merged.');
     return;
   }
 
-  console.log(clc.yellow('The branch was not merged'));
+  print('git merge ' + branchName);
+  print(await exec(['merge', '--', branchName]));
+
+  // Only local branches can be deleted; never remove remote refs.
+  const locals = (await exec(['for-each-ref', '--format=%(refname)', 'refs/heads/'])).split('\n');
+  if (!locals.includes('refs/heads/' + branchName)) return;
+
+  const { remove } = await prompt({
+    type: 'confirm',
+    name: 'remove',
+    message: 'Delete merged branch ' + branchName + '?',
+    default: true,
+  });
+  if (remove) await deleteBranches([branchName], false, false);
 }

package/src/index.ts

@@ -1,42 +1,47 @@
-import { ask } from './ask';
-import { Commands, getHelp, getWishOfUser } from './cli-commands';
+import { ask, askBranches } from './ask';
+import { Commands, getHelp, parseArgs } from './cli-commands';
 import { BranchesType, checkoutBranch, getBranches, getCurrentBranchName } from './commands';
-import { deleteBranch } from './commands/delete-barnch';
+import { deleteBranches } from './commands/delete-barnch';
 import { mergeBranch } from './commands/merge-branch';
+import { finishTerminal, installInterruptHandler, print, startTerminal } from './terminal';
 
-const run = async () => {
-  const userWish = getWishOfUser();
-
-  if (Commands.Help === userWish) {
+export const run = async () => {
+  const { command, filter } = parseArgs();
+  if (command === Commands.Help) {
     console.log(getHelp());
     return;
   }
 
-  let branchType: BranchesType = BranchesType.All;
-
-  if (Commands.ShowMerged === userWish) {
-    branchType = BranchesType.Merged;
-  } else if (Commands.ShowUnMerged === userWish) {
-    branchType = BranchesType.NotMerged;
-  }
-
-  const branches = await getBranches(branchType);
-
-  const { branch } = await ask('Select branch', branches);
-
-  if (Commands.DeleteBranch === userWish) {
-    deleteBranch(branch);
-    return;
+  const branchType = command === Commands.ShowMerged ? BranchesType.Merged
+    : command === Commands.ShowUnMerged ? BranchesType.NotMerged : BranchesType.All;
+  const deleting = command === Commands.DeleteBranch;
+  let branches = await getBranches(branchType, deleting);
+  if (deleting) {
+    const currentBranch = await getCurrentBranchName();
+    branches = branches.filter(branch => branch !== currentBranch);
+    if (!branches.length) throw new Error('No local branches available for deletion.');
   }
 
-  if (Commands.MergeBranch === userWish) {
-    mergeBranch(branch);
-    return;
+  startTerminal();
+  if (deleting) {
+    const selected = await askBranches('Select branches to delete (Space to select)', branches, filter);
+    await deleteBranches(selected);
+  } else {
+    const { branch } = await ask('Select branch', branches, filter);
+    if (command === Commands.MergeBranch) await mergeBranch(branch);
+    else {
+      await checkoutBranch(branch);
+      print(await getCurrentBranchName());
+    }
   }
-
-  await checkoutBranch(branch);
-
-  await getCurrentBranchName()
 };
 
-run();
+const removeInterruptHandler = installInterruptHandler();
+run().catch(error => {
+  finishTerminal();
+  console.error('Error: ' + (error instanceof Error ? error.message : String(error)));
+  process.exitCode = 1;
+}).finally(() => {
+  finishTerminal();
+  removeInterruptHandler();
+});

package/src/prompt.ts

@@ -0,0 +1,18 @@
+import inquirer, { Answers, QuestionCollection } from 'inquirer';
+import { finishTerminal } from './terminal';
+
+export function prompt<T extends Answers = Answers>(questions: QuestionCollection<T>): Promise<T> {
+  const result = inquirer.prompt<T>(questions);
+  // Inquirer 8 re-sends SIGINT asynchronously and may exit before Node handles
+  // it. Handle readline's raw-mode Ctrl+C synchronously instead.
+  const ui = result.ui as any;
+  if (ui) {
+    ui.rl.removeListener('SIGINT', ui.onForceClose);
+    ui.rl.once('SIGINT', () => {
+      ui.close();
+      finishTerminal(true);
+      process.exit(130);
+    });
+  }
+  return result;
+}

package/src/terminal.ts

@@ -0,0 +1,32 @@
+// Keep interactive output isolated from the user's shell history.
+let active = false;
+let messages: string[] = [];
+
+export function startTerminal() {
+  active = Boolean(process.stdout.isTTY && process.stdin.isTTY);
+  messages = [];
+  if (active) process.stdout.write('\x1b[?1049h');
+}
+
+export function print(message: string) {
+  if (!message.trim()) return;
+  if (active) messages.push(message.trimEnd());
+  console.log(message.trimEnd());
+}
+
+export function finishTerminal(cancelled = false) {
+  if (!active) return;
+  active = false;
+  process.stdout.write('\x1b[?1049l\x1b[?25h');
+  if (!cancelled && messages.length) console.log(messages.join('\n'));
+  messages = [];
+}
+
+export function installInterruptHandler() {
+  const onInterrupt = () => {
+    finishTerminal(true);
+    process.exit(130);
+  };
+  process.on('SIGINT', onInterrupt);
+  return () => process.removeListener('SIGINT', onInterrupt);
+}