avil13-co 2.2.5 → 2.4.0

package/src/__tests__/terminal.spec.ts

@@ -0,0 +1,56 @@
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { finishTerminal, print, startTerminal } from '../terminal';
+
+const descriptors = [process.stdin, process.stdout].map(stream =>
+  Object.getOwnPropertyDescriptor(stream, 'isTTY'));
+
+function setTTY(value: boolean) {
+  for (const stream of [process.stdin, process.stdout]) {
+    Object.defineProperty(stream, 'isTTY', { value, configurable: true });
+  }
+}
+
+beforeEach(() => {
+  vi.spyOn(process.stdout, 'write').mockReturnValue(true);
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+});
+
+afterEach(() => {
+  finishTerminal(true);
+  [process.stdin, process.stdout].forEach((stream, index) => {
+    const descriptor = descriptors[index];
+    if (descriptor) Object.defineProperty(stream, 'isTTY', descriptor);
+    else delete (stream as any).isTTY;
+  });
+  vi.restoreAllMocks();
+});
+
+it('does not emit screen controls outside a TTY', () => {
+  setTTY(false);
+  startTerminal();
+  print('result');
+  finishTerminal();
+  expect(process.stdout.write).not.toHaveBeenCalled();
+  expect(console.log).toHaveBeenCalledExactlyOnceWith('result');
+});
+
+it('restores the screen and replays results on success only once', () => {
+  setTTY(true);
+  startTerminal();
+  print('result');
+  finishTerminal();
+  finishTerminal();
+  expect(process.stdout.write).toHaveBeenNthCalledWith(1, '\x1b[?1049h');
+  expect(process.stdout.write).toHaveBeenNthCalledWith(2, '\x1b[?1049l\x1b[?25h');
+  expect(process.stdout.write).toHaveBeenCalledTimes(2);
+  expect(console.log).toHaveBeenCalledTimes(2);
+});
+
+it('restores the screen without replaying output on cancellation', () => {
+  setTTY(true);
+  startTerminal();
+  print('discard this');
+  finishTerminal(true);
+  expect(process.stdout.write).toHaveBeenLastCalledWith('\x1b[?1049l\x1b[?25h');
+  expect(console.log).toHaveBeenCalledTimes(1);
+});

package/src/ask.ts

@@ -1,62 +1,66 @@
 import inquirer from 'inquirer';
+import { prompt } from './prompt';
 
-inquirer.registerPrompt(
-  'autocomplete',
-  require('inquirer-autocomplete-prompt')
-);
+const AutocompletePrompt = require('inquirer-autocomplete-prompt');
 
-const specSymbols = {
-  _saveCursor: '\x1b7',
-  _restoreCursor: '\x1b8',
-  _clear: '\x1b[H\x1b[2J',
-};
+class FilteredAutocompletePrompt extends AutocompletePrompt {
+  _run(callback) {
+    // `default` in the plugin selects a choice, it does not fill the input.
+    const filter = this.opt.initialFilter || '';
+    this.rl.line = filter;
+    this.rl.cursor = filter.length;
+    return super._run(callback);
+  }
+}
 
-export const ask = async (message: string, choices: string[]) => {
-  const prompt = inquirer.prompt({
-    //@ts-ignore
+inquirer.registerPrompt('autocomplete', FilteredAutocompletePrompt as any);
+
+export const ask = async (message: string, choices: string[], initialFilter = '') => {
+  return prompt<{ branch: string }>({
     type: 'autocomplete',
     name: 'branch',
     message,
-    source(answersSoFar, input = '') {
-      let list = choices.filter(choiceItem => checkItem(choiceItem, input));
-
-      list = list.sort((a, b) => {
-        return sortOrder(input, a, b);
-      });
-
-      return Promise.resolve(list);
-    }
-  });
-
-  return prompt;
+    initialFilter,
+    source(_answers, input = initialFilter) {
+      return Promise.resolve(choices
+        .filter(choice => checkItem(choice, input))
+        .sort((a, b) => sortOrder(input, a, b)));
+    },
+  } as any);
 };
 
-//
-export function checkItem(item: string, filterString: string): boolean {
-  const reg = getRegExp(filterString);
-
-  return reg.test(item);
+export async function askBranches(message: string, choices: string[], filter = ''): Promise<string[]> {
+  const filtered = choices.filter(choice => checkItem(choice, filter));
+  if (!filtered.length) throw new Error('No branches match the filter.');
+  const { branches } = await prompt<{ branches: string[] }>({
+    type: 'checkbox',
+    name: 'branches',
+    message,
+    choices: filtered,
+    validate: (selected: string[]) => selected.length > 0 || 'Select at least one branch.',
+  });
+  return branches;
 }
 
-export function sortOrder(searchString: string, name1: string, name2: string): -1 | 1 {
-  if (!name1.includes(searchString)) {
-    return 1;
-  }
-  if (!name2.includes(searchString)) {
-    return -1;
-  }
-
-  if ((name2.indexOf(searchString) < name1.indexOf(searchString))) {
-    return 1;
+export function checkItem(item: string, filterString: string): boolean {
+  // Literal, case-insensitive subsequence matching; no user-supplied regex.
+  const needle = filterString.replace(/\s/g, '').toLowerCase();
+  const haystack = item.toLowerCase();
+  let position = 0;
+  for (const character of needle) {
+    position = haystack.indexOf(character, position);
+    if (position === -1) return false;
+    position++;
   }
-
-  return -1;
+  return true;
 }
 
-
-function getRegExp(filterString: string) {
-  return new RegExp(
-    filterString.split('').map(s => s.trim()).filter(Boolean).join('.*').replace('.*.*', '.*'),
-    'gi',
-  );
+export function sortOrder(searchString: string, name1: string, name2: string): number {
+  const search = searchString.toLowerCase();
+  const first = name1.toLowerCase().indexOf(search);
+  const second = name2.toLowerCase().indexOf(search);
+  if (first === second) return 0;
+  if (first === -1) return 1;
+  if (second === -1) return -1;
+  return first - second;
 }

package/src/cli-commands/index.ts

@@ -1,7 +1,3 @@
-import { clc } from '../color';
-
-const args = process.argv.slice(2);
-
 export enum Commands {
   Unknown = 0,
   Help = 1,
@@ -9,52 +5,46 @@ export enum Commands {
   MergeBranch = 4,
   ShowMerged = 8,
   ShowUnMerged = 16,
-};
-
-export const getWishOfUser = (firstArg?: string): Commands => {
-  const arg: string = firstArg || args[0];
-
-  switch (true) {
-    case ['help', '-h', '--h', '--help'].includes(arg):
-      return Commands.Help;
-
-    case ['-M', 'merge'].includes(arg):
-      return Commands.MergeBranch;
-
-    case ['-D', 'rm'].includes(arg):
-      return Commands.DeleteBranch;
-
-    case ['-sm', '--show-merged'].includes(arg):
-      return Commands.ShowMerged;
+  Sync = 32,
+}
 
-    case ['-un', '--no-merged'].includes(arg):
-      return Commands.ShowUnMerged;
+export const getWishOfUser = (firstArg = process.argv[2]): Commands => {
+  if (['help', '-h', '--h', '--help'].includes(firstArg)) return Commands.Help;
+  if (['-M', 'merge'].includes(firstArg)) return Commands.MergeBranch;
+  if (['-D', 'rm'].includes(firstArg)) return Commands.DeleteBranch;
+  if (firstArg === '-p') return Commands.Sync;
+  if (['m', '-sm', '--show-merged'].includes(firstArg)) return Commands.ShowMerged;
+  if (['un', '-un', '--no-merged'].includes(firstArg)) return Commands.ShowUnMerged;
+  return Commands.Unknown;
+};
 
-    default:
-      return Commands.Unknown;
+export function parseArgs(args = process.argv.slice(2)) {
+  const command = getWishOfUser(args[0] || '');
+  if (!args.length) return { command, filter: '' };
+  if (command === Commands.Unknown && args[0] !== '-') {
+    throw new Error('Unknown option: ' + args[0] + '. Use co --help.');
+  }
+  if (command === Commands.Sync && args.length > 1) {
+    throw new Error('co -p synchronizes all branches and does not accept a filter.');
   }
+  const rest = args.slice(1);
+  if (rest[0] === '-') rest.shift();
+  return { command, filter: rest.join(' ') };
 }
 
-
-export const getHelp = (): string => {
-  return `
+export const getHelp = (): string => `
 DESCRIPTION:
-  A console program for quickly switching between branches
-
-OPTIONS:
-  help, -h, --h, --help
-    Showing this message
-
-  -M, merge
-    Merge branch
-
-  -sm, --show-merged
-    Showing merged branches
-
-  -un, --no-merged
-    Showing not merged branches
-
-  -D, rm
-    Delete the selected branch
+  Quickly switch, merge, delete and synchronize Git branches.
+
+USAGE:
+  co                         Select a branch to check out
+  co - 1234                  Start with an editable search filter
+  co -M [- filter]           Merge, then offer to delete the source branch [Y/n]
+  co -D [- filter]           Delete multiple local branches (Space to select)
+  co -p                     Fetch and safely sync all local branches (like hub sync)
+  co m, -sm, --show-merged   Show merged branches
+  co un, -un, --no-merged    Show unmerged branches
+  co help, -h, --h, --help   Show this message
+
+  Ctrl+C cancels and restores the previous terminal screen.
 `;
-}

package/src/commands/checkout-branch.ts

@@ -1,16 +1,8 @@
 import { exec } from './exec';
-import { clc } from '../color';
+import { print } from '../terminal';
 
-//
 export async function checkoutBranch(branchName: string) {
-  if (!branchName) {
-    throw new Error('No branch...');
-  }
-
-  const checkoutCommand = `git checkout ${branchName}`;
-
-  console.log(' ' + clc.green('git checkout', branchName) + '\n');
-
-  const checkoutCommandResult = await exec(checkoutCommand);
-  console.log(checkoutCommandResult);
+  if (!branchName) throw new Error('No branch selected.');
+  print('git checkout ' + branchName);
+  print(await exec(['checkout', branchName, '--']));
 }

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/commands/sync-branches.ts

@@ -0,0 +1,94 @@
+import { exec } from './exec';
+import { getCurrentBranchName } from './get-current-branch-name';
+import { print } from '../terminal';
+
+/** Synchronize local branches without switching branches or rewriting commits. */
+export async function syncBranches() {
+  const remotes = (await exec(['remote'])).split('\n').filter(Boolean);
+  if (!remotes.length) throw new Error('No remotes configured. Add a Git remote before running co -p.');
+
+  print('Fetching all remotes...');
+  print(await exec(['fetch', '--all', '--prune']));
+
+  const refs = new Map((await exec(['for-each-ref', '--format=%(refname)%09%(objectname)']))
+    .split('\n').filter(Boolean).map(line => {
+      const [ref, oid] = line.split('\t');
+      return [ref, oid] as [string, string];
+    }));
+  const branches = (await exec([
+    'for-each-ref', '--format=%(refname)%09%(objectname)%09%(upstream)', 'refs/heads/',
+  ])).split('\n').filter(Boolean).map(line => {
+    const [ref, oid, upstream = ''] = line.split('\t');
+    return { ref, oid, upstream, name: ref.slice('refs/heads/'.length) };
+  });
+  const current = 'refs/heads/' + await getCurrentBranchName();
+  const checkedOut = new Set((await exec(['worktree', 'list', '--porcelain', '-z']))
+    .split('\0').filter(field => field.startsWith('branch ')).map(field => field.slice(7)));
+  const dirty = Boolean(await exec(['status', '--porcelain']));
+  const stale: typeof branches = [];
+  const errors: string[] = [];
+
+  for (const branch of branches) {
+    try {
+      let upstream = branch.upstream;
+      if (!upstream) {
+        const candidates = remotes.map(remote => 'refs/remotes/' + remote + '/' + branch.name)
+          .filter(ref => refs.has(ref));
+        const origin = 'refs/remotes/origin/' + branch.name;
+        if (candidates.includes(origin)) upstream = origin;
+        else if (candidates.length === 1) upstream = candidates[0];
+        else {
+          print(branch.name + ': skipped (' + (candidates.length ? 'ambiguous upstream' : 'no upstream') + ').');
+          continue;
+        }
+      }
+
+      const target = refs.get(upstream);
+      if (!target) {
+        if (upstream.startsWith('refs/remotes/')) stale.push(branch);
+        else print(branch.name + ': skipped (upstream is missing).');
+        continue;
+      }
+
+      const [ahead, behind] = (await exec(['rev-list', '--left-right', '--count', branch.oid + '...' + target]))
+        .split(/\s+/).map(Number);
+      if (ahead) {
+        print(branch.name + ': warning: ' + ahead + ' unpushed commit(s)' +
+          (behind ? ', diverged from upstream by ' + behind + ' commit(s)' : '') + '; kept unchanged.');
+      } else if (!behind) {
+        print(branch.name + ': up to date.');
+      } else if (checkedOut.has(branch.ref) && branch.ref !== current) {
+        print(branch.name + ': skipped (checked out in another worktree).');
+      } else if (branch.ref === current && dirty) {
+        print(branch.name + ': skipped (working tree has uncommitted changes).');
+      } else {
+        if (branch.ref === current) {
+          print(await exec(['merge', '--ff-only', '--no-edit', '--', target]));
+        } else {
+          // Compare-and-swap protects against concurrent changes to the local ref.
+          await exec(['update-ref', '-m', 'co sync: fast-forward', branch.ref, target, branch.oid]);
+        }
+        print(branch.name + ': fast-forwarded.');
+      }
+    } catch (error) {
+      errors.push(branch.name + ': ' + (error instanceof Error ? error.message : String(error)));
+    }
+  }
+
+  // Check merged status after fast-forwards so newly integrated branches can
+  // be removed too. Never force-delete or delete a checked-out branch.
+  for (const branch of stale) {
+    try {
+      if (checkedOut.has(branch.ref)) {
+        print(branch.name + ': kept (upstream deleted, branch is checked out).');
+      } else if (await exec(['rev-list', '--count', branch.oid, '--not', 'HEAD']) !== '0') {
+        print(branch.name + ': warning: upstream deleted, unmerged commits kept.');
+      } else {
+        print(await exec(['branch', '-d', '--', branch.name]));
+      }
+    } catch (error) {
+      errors.push(branch.name + ': ' + (error instanceof Error ? error.message : String(error)));
+    }
+  }
+  if (errors.length) throw new Error(errors.join('\n'));
+}