avil13-co 2.2.5 → 2.3.0

package/dist/index.js

@@ -1,34 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
 const ask_1 = require("./ask");
 const cli_commands_1 = require("./cli-commands");
 const commands_1 = require("./commands");
 const delete_barnch_1 = require("./commands/delete-barnch");
 const merge_branch_1 = require("./commands/merge-branch");
+const terminal_1 = require("./terminal");
 const run = async () => {
-    const userWish = (0, cli_commands_1.getWishOfUser)();
-    if (cli_commands_1.Commands.Help === userWish) {
+    const { command, filter } = (0, cli_commands_1.parseArgs)();
+    if (command === cli_commands_1.Commands.Help) {
         console.log((0, cli_commands_1.getHelp)());
         return;
     }
-    let branchType = commands_1.BranchesType.All;
-    if (cli_commands_1.Commands.ShowMerged === userWish) {
-        branchType = commands_1.BranchesType.Merged;
+    const branchType = command === cli_commands_1.Commands.ShowMerged ? commands_1.BranchesType.Merged
+        : command === cli_commands_1.Commands.ShowUnMerged ? commands_1.BranchesType.NotMerged : commands_1.BranchesType.All;
+    const deleting = command === cli_commands_1.Commands.DeleteBranch;
+    let branches = await (0, commands_1.getBranches)(branchType, deleting);
+    if (deleting) {
+        const currentBranch = await (0, commands_1.getCurrentBranchName)();
+        branches = branches.filter(branch => branch !== currentBranch);
+        if (!branches.length)
+            throw new Error('No local branches available for deletion.');
     }
-    else if (cli_commands_1.Commands.ShowUnMerged === userWish) {
-        branchType = commands_1.BranchesType.NotMerged;
+    (0, terminal_1.startTerminal)();
+    if (deleting) {
+        const selected = await (0, ask_1.askBranches)('Select branches to delete (Space to select)', branches, filter);
+        await (0, delete_barnch_1.deleteBranches)(selected);
     }
-    const branches = await (0, commands_1.getBranches)(branchType);
-    const { branch } = await (0, ask_1.ask)('Select branch', branches);
-    if (cli_commands_1.Commands.DeleteBranch === userWish) {
-        (0, delete_barnch_1.deleteBranch)(branch);
-        return;
-    }
-    if (cli_commands_1.Commands.MergeBranch === userWish) {
-        (0, merge_branch_1.mergeBranch)(branch);
-        return;
+    else {
+        const { branch } = await (0, ask_1.ask)('Select branch', branches, filter);
+        if (command === cli_commands_1.Commands.MergeBranch)
+            await (0, merge_branch_1.mergeBranch)(branch);
+        else {
+            await (0, commands_1.checkoutBranch)(branch);
+            (0, terminal_1.print)(await (0, commands_1.getCurrentBranchName)());
+        }
     }
-    await (0, commands_1.checkoutBranch)(branch);
-    await (0, commands_1.getCurrentBranchName)();
 };
-run();
+exports.run = run;
+const removeInterruptHandler = (0, terminal_1.installInterruptHandler)();
+(0, exports.run)().catch(error => {
+    (0, terminal_1.finishTerminal)();
+    console.error('Error: ' + (error instanceof Error ? error.message : String(error)));
+    process.exitCode = 1;
+}).finally(() => {
+    (0, terminal_1.finishTerminal)();
+    removeInterruptHandler();
+});

package/dist/prompt.d.ts

@@ -0,0 +1,2 @@
+import { Answers, QuestionCollection } from 'inquirer';
+export declare function prompt<T extends Answers = Answers>(questions: QuestionCollection<T>): Promise<T>;

package/dist/prompt.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompt = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const terminal_1 = require("./terminal");
+function prompt(questions) {
+    const result = inquirer_1.default.prompt(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;
+    if (ui) {
+        ui.rl.removeListener('SIGINT', ui.onForceClose);
+        ui.rl.once('SIGINT', () => {
+            ui.close();
+            (0, terminal_1.finishTerminal)(true);
+            process.exit(130);
+        });
+    }
+    return result;
+}
+exports.prompt = prompt;

package/dist/terminal.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+export declare function startTerminal(): void;
+export declare function print(message: string): void;
+export declare function finishTerminal(cancelled?: boolean): void;
+export declare function installInterruptHandler(): () => NodeJS.Process;

package/dist/terminal.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installInterruptHandler = exports.finishTerminal = exports.print = exports.startTerminal = void 0;
+// Keep interactive output isolated from the user's shell history.
+let active = false;
+let messages = [];
+function startTerminal() {
+    active = Boolean(process.stdout.isTTY && process.stdin.isTTY);
+    messages = [];
+    if (active)
+        process.stdout.write('\x1b[?1049h');
+}
+exports.startTerminal = startTerminal;
+function print(message) {
+    if (!message.trim())
+        return;
+    if (active)
+        messages.push(message.trimEnd());
+    console.log(message.trimEnd());
+}
+exports.print = print;
+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 = [];
+}
+exports.finishTerminal = finishTerminal;
+function installInterruptHandler() {
+    const onInterrupt = () => {
+        finishTerminal(true);
+        process.exit(130);
+    };
+    process.on('SIGINT', onInterrupt);
+    return () => process.removeListener('SIGINT', onInterrupt);
+}
+exports.installInterruptHandler = installInterruptHandler;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "avil13-co",
-  "version": "2.2.5",
+  "version": "2.3.0",
   "description": "",
   "main": "dist/index.js",
   "public": true,

package/src/__tests__/ask.spec.ts

@@ -1,7 +1,22 @@
 import { expect, it } from 'vitest';
-import { sortOrder } from '../ask';
+import { checkItem, sortOrder } from '../ask';
 
-it('should ', () => {
+it.each(['[', '(', '*', '+', '?', '.', '\\', '$', '^'])('treats %s literally', symbol => {
+  expect(checkItem('task/' + symbol + '1234', symbol)).toBe(true);
+  expect(checkItem('task/1234', symbol)).toBe(false);
+});
+
+it('matches case-insensitive subsequences and ignores spaces', () => {
+  expect(checkItem('feature/TASK-1234', 't 14')).toBe(true);
+  expect(checkItem('feature/TASK-1234', '4321')).toBe(false);
+});
+
+it('returns zero for equivalent ranks', () => {
+  expect(sortOrder('task', 'first', 'second')).toBe(0);
+  expect(sortOrder('', 'first', 'second')).toBe(0);
+});
+
+it('ranks contiguous matches by position and keeps other choices stable', () => {
   const list = [
     'chore/EDODEV-10449-act-master',
     'chore/release-to-master',

package/src/__tests__/cli-commands.spec.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { Commands, parseArgs } from '../cli-commands';
+
+describe('arguments', () => {
+  it('defaults to checkout', () => {
+    expect(parseArgs([])).toEqual({ command: Commands.Unknown, filter: '' });
+  });
+  it('preloads a checkout filter', () => {
+    expect(parseArgs(['-', '1234'])).toEqual({ command: Commands.Unknown, filter: '1234' });
+  });
+  it('accepts filters with commands', () => {
+    expect(parseArgs(['-D', '-', 'task', '1234'])).toEqual({
+      command: Commands.DeleteBranch, filter: 'task 1234',
+    });
+  });
+  it.each(['m', '-sm', '--show-merged'])('accepts merged alias %s', alias => {
+    expect(parseArgs([alias]).command).toBe(Commands.ShowMerged);
+  });
+  it.each(['un', '-un', '--no-merged'])('accepts unmerged alias %s', alias => {
+    expect(parseArgs([alias]).command).toBe(Commands.ShowUnMerged);
+  });
+  it('reports unknown options', () => {
+    expect(() => parseArgs(['--typo'])).toThrow('Unknown option');
+  });
+});

package/src/__tests__/commands.spec.ts

@@ -0,0 +1,110 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { execFileSync } from 'child_process';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import inquirer from 'inquirer';
+import { exec } from '../commands/exec';
+import { BranchesType, getBranches } from '../commands/get-branches';
+import { checkoutBranch } from '../commands/checkout-branch';
+import { deleteBranches } from '../commands/delete-barnch';
+import { mergeBranch } from '../commands/merge-branch';
+
+const context = vi.hoisted(() => ({ cwd: '' }));
+vi.mock('child_process', async importOriginal => {
+  const actual = await importOriginal<typeof import('child_process')>();
+  return {
+    ...actual,
+    execFile: (file, args, callback) => actual.execFile(file, args, { cwd: context.cwd }, callback),
+  };
+});
+
+function git(...args: string[]) {
+  return execFileSync('git', args, { cwd: context.cwd, encoding: 'utf8' }).trim();
+}
+
+beforeEach(() => {
+  context.cwd = mkdtempSync(join(tmpdir(), 'co-test-'));
+  git('init', '-q', '-b', 'main');
+  git('config', 'user.name', 'Test');
+  git('config', 'user.email', 'test@example.test');
+  git('commit', '-q', '--allow-empty', '-m', 'initial');
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  rmSync(context.cwd, { recursive: true, force: true });
+});
+
+describe('Git commands', () => {
+  it('reports Git diagnostics on failure', async () => {
+    await expect(exec(['checkout', 'missing', '--'])).rejects.toThrow('missing');
+  });
+
+  it('checks out branch names containing shell metacharacters literally', async () => {
+    const branch = 'task/1234;echo-pwned';
+    git('branch', branch);
+    await checkoutBranch(branch);
+    expect(git('branch', '--show-current')).toBe(branch);
+  });
+
+  it('preserves local origin-prefixed branches and deduplicates origin remote refs', async () => {
+    git('branch', 'origin/local');
+    git('update-ref', 'refs/remotes/origin/main', 'HEAD');
+    git('symbolic-ref', 'refs/remotes/origin/HEAD', 'refs/remotes/origin/main');
+    expect(await getBranches(BranchesType.All)).toEqual(['main', 'origin/local']);
+  });
+
+  it('excludes remote refs from deletion candidates', async () => {
+    git('update-ref', 'refs/remotes/origin/remote-only', 'HEAD');
+    expect(await getBranches(BranchesType.All, true)).toEqual(['main']);
+  });
+
+  it('deletes multiple selected branches after one confirmation', async () => {
+    git('branch', 'one');
+    git('branch', 'two');
+    const prompt = vi.spyOn(inquirer, 'prompt').mockResolvedValue({ answer: true });
+    await deleteBranches(['one', 'two']);
+    expect(git('branch', '--format=%(refname:short)')).toBe('main');
+    expect(prompt).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not delete when confirmation is declined', async () => {
+    git('branch', 'one');
+    vi.spyOn(inquirer, 'prompt').mockResolvedValue({ answer: false });
+    await deleteBranches(['one']);
+    expect(git('branch', '--list', 'one')).toContain('one');
+  });
+
+  it('continues deleting and reports partial failures', async () => {
+    git('branch', 'one');
+    await expect(deleteBranches(['missing', 'one'], false)).rejects.toThrow('missing');
+    expect(git('branch', '--list', 'one')).toBe('');
+  });
+
+  it('offers safe deletion after successful merge, defaulting to yes', async () => {
+    git('branch', 'feature');
+    const prompt = vi.spyOn(inquirer, 'prompt')
+      .mockResolvedValueOnce({ answer: true })
+      .mockResolvedValueOnce({ remove: true });
+    await mergeBranch('feature');
+    expect(prompt.mock.calls[1][0]).toMatchObject({ default: true });
+    expect(git('branch', '--list', 'feature')).toBe('');
+  });
+
+  it('keeps the merged branch if deletion is declined', async () => {
+    git('branch', 'feature');
+    vi.spyOn(inquirer, 'prompt')
+      .mockResolvedValueOnce({ answer: true })
+      .mockResolvedValueOnce({ remove: false });
+    await mergeBranch('feature');
+    expect(git('branch', '--list', 'feature')).toContain('feature');
+  });
+
+  it('never offers deletion after a failed merge', async () => {
+    const prompt = vi.spyOn(inquirer, 'prompt').mockResolvedValue({ answer: true });
+    await expect(mergeBranch('missing')).rejects.toThrow('missing');
+    expect(prompt).toHaveBeenCalledTimes(1);
+  });
+});

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,40 @@ 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;
+}
 
-    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 (['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.');
   }
+  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 and delete 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 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, '--']));
 }