avil13-co 2.2.5 → 2.4.0

package/README.md

@@ -1,40 +1,81 @@
 # avil13/co
 
-## Simplest way for use "git checkout"
+Interactive Git branch checkout, merge, deletion and synchronization.
 
 ![demo](assets/cli-demo.gif)
 
-Install:
+## Install
 
 ```sh
 npm install -g avil13-co
 ```
 
-Type alias "`co`" for switch branch.
-
-# Usage
+## Usage
 
 ```sh
-# Shows a list of branches that can be switched to
-co
+co                  # Search for a branch and check it out
+co - 1234           # Pre-fill the editable search input with "1234"
+co m                # Show merged branches (also: -sm, --show-merged)
+co un               # Show unmerged branches (also: -un, --no-merged)
+co -M               # Merge a selected branch (also: merge)
+co -D               # Delete multiple local branches (also: rm)
+co -p               # Fetch and safely sync all local branches (like hub sync)
+co -h               # Show help
 ```
 
-```sh
-# Shows help message
-co -h
-```
+Search is case-insensitive and supports subsequences; special characters are literal.
+Filters also work with commands, for example `co -M - 1234` or `co -D - 1234`.
+For deletion, the initial filter restricts the checkbox list.
 
-```sh
-# Showing merged branches
-co m
-```
+### Delete branches
 
-```sh
-# Showing not merged branches
-co un
-```
+Use **Space** to select branches, then **Enter** to confirm the selection.
+A separate confirmation defaults to **No**. Only local branches are listed;
+the current branch is excluded. Like Git's `-D`, this explicitly requested
+operation can delete unmerged branches. Failures are reported per branch,
+without skipping the remaining selections.
+
+### Merge
+
+After a successful, confirmed merge, `co` offers to delete the source branch
+with **Yes** as the default (`[Y/n]`). This uses safe deletion (`git branch -d`),
+not forced deletion. Remote-only branches are not offered for deletion.
+A failed merge never triggers the deletion question.
+
+### Synchronize branches
+
+`co -p` works like `hub sync`, without requiring `hub`:
+
+- Fetches all remotes with `--prune`.
+- Fast-forwards local branches to their configured upstreams, including branches
+  that are not currently checked out. It does not create merge commits or rebase.
+- Without an upstream, uses the same-named branch on `origin`, or a unique match
+  on another remote. Ambiguous matches are skipped; tracking configuration is not changed.
+- Warns about unpushed commits or diverged history and leaves those branches unchanged.
+- Safely deletes branches whose remote upstream disappeared only when they are
+  merged into the current `HEAD`. Unmerged and checked-out branches are kept.
+- Skips updating the current branch if the working tree is dirty, and never updates
+  branches checked out in other worktrees.
+
+This command synchronizes **all** local branches without a selection prompt and
+accepts no search filter. It never pushes, force-resets, or stashes changes.
+Network and Git failures are reported with exit code 1; skipped branches are
+reported without treating them as failures.
+
+### Cancel and errors
+
+**Ctrl+C** exits with code 130 and restores the previous terminal screen,
+removing this session's interactive output. Completed Git operations are not
+rolled back. On normal completion, command results remain visible.
+Screen switching is only enabled in an interactive terminal.
+
+Git errors are printed without an unhandled rejection and return exit code 1.
+Git is invoked directly, without shell interpolation of branch names.
+
+## Development
 
 ```sh
-# Choosing a branch to delete
-co -D
+npm test
+npm run type-check
+npm run build
 ```

package/dist/ask.d.ts

@@ -1,5 +1,6 @@
-export declare const ask: (message: string, choices: string[]) => Promise<{
-    branch: any;
+export declare const ask: (message: string, choices: string[], initialFilter?: string) => Promise<{
+    branch: string;
 }>;
+export declare function askBranches(message: string, choices: string[], filter?: string): Promise<string[]>;
 export declare function checkItem(item: string, filterString: string): boolean;
-export declare function sortOrder(searchString: string, name1: string, name2: string): -1 | 1;
+export declare function sortOrder(searchString: string, name1: string, name2: string): number;

package/dist/ask.js

@@ -3,50 +3,72 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortOrder = exports.checkItem = exports.ask = void 0;
+exports.sortOrder = exports.checkItem = exports.askBranches = exports.ask = void 0;
 const inquirer_1 = __importDefault(require("inquirer"));
-inquirer_1.default.registerPrompt('autocomplete', require('inquirer-autocomplete-prompt'));
-const specSymbols = {
-    _saveCursor: '\x1b7',
-    _restoreCursor: '\x1b8',
-    _clear: '\x1b[H\x1b[2J',
-};
-const ask = async (message, choices) => {
-    const prompt = inquirer_1.default.prompt({
-        //@ts-ignore
+const prompt_1 = require("./prompt");
+const AutocompletePrompt = require('inquirer-autocomplete-prompt');
+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);
+    }
+}
+inquirer_1.default.registerPrompt('autocomplete', FilteredAutocompletePrompt);
+const ask = async (message, choices, initialFilter = '') => {
+    return (0, prompt_1.prompt)({
         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);
-        }
+        initialFilter,
+        source(_answers, input = initialFilter) {
+            return Promise.resolve(choices
+                .filter(choice => checkItem(choice, input))
+                .sort((a, b) => sortOrder(input, a, b)));
+        },
     });
-    return prompt;
 };
 exports.ask = ask;
-//
+async function askBranches(message, choices, filter = '') {
+    const filtered = choices.filter(choice => checkItem(choice, filter));
+    if (!filtered.length)
+        throw new Error('No branches match the filter.');
+    const { branches } = await (0, prompt_1.prompt)({
+        type: 'checkbox',
+        name: 'branches',
+        message,
+        choices: filtered,
+        validate: (selected) => selected.length > 0 || 'Select at least one branch.',
+    });
+    return branches;
+}
+exports.askBranches = askBranches;
 function checkItem(item, filterString) {
-    const reg = getRegExp(filterString);
-    return reg.test(item);
+    // 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 true;
 }
 exports.checkItem = checkItem;
 function sortOrder(searchString, name1, name2) {
-    if (!name1.includes(searchString)) {
+    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 (!name2.includes(searchString)) {
+    if (second === -1)
         return -1;
-    }
-    if ((name2.indexOf(searchString) < name1.indexOf(searchString))) {
-        return 1;
-    }
-    return -1;
+    return first - second;
 }
 exports.sortOrder = sortOrder;
-function getRegExp(filterString) {
-    return new RegExp(filterString.split('').map(s => s.trim()).filter(Boolean).join('.*').replace('.*.*', '.*'), 'gi');
-}

package/dist/cli-commands/index.d.ts

@@ -4,7 +4,12 @@ export declare enum Commands {
     DeleteBranch = 2,
     MergeBranch = 4,
     ShowMerged = 8,
-    ShowUnMerged = 16
+    ShowUnMerged = 16,
+    Sync = 32
 }
-export declare const getWishOfUser: (firstArg?: string | undefined) => Commands;
+export declare const getWishOfUser: (firstArg?: string) => Commands;
+export declare function parseArgs(args?: string[]): {
+    command: Commands;
+    filter: string;
+};
 export declare const getHelp: () => string;

package/dist/cli-commands/index.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHelp = exports.getWishOfUser = exports.Commands = void 0;
-const args = process.argv.slice(2);
+exports.getHelp = exports.parseArgs = exports.getWishOfUser = exports.Commands = void 0;
 var Commands;
 (function (Commands) {
     Commands[Commands["Unknown"] = 0] = "Unknown";
@@ -10,46 +9,54 @@ var Commands;
     Commands[Commands["MergeBranch"] = 4] = "MergeBranch";
     Commands[Commands["ShowMerged"] = 8] = "ShowMerged";
     Commands[Commands["ShowUnMerged"] = 16] = "ShowUnMerged";
+    Commands[Commands["Sync"] = 32] = "Sync";
 })(Commands = exports.Commands || (exports.Commands = {}));
-;
-const getWishOfUser = (firstArg) => {
-    const arg = 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;
-        default:
-            return Commands.Unknown;
-    }
+const getWishOfUser = (firstArg = process.argv[2]) => {
+    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;
 };
 exports.getWishOfUser = getWishOfUser;
-const getHelp = () => {
-    return `
+function parseArgs(args = process.argv.slice(2)) {
+    const command = (0, exports.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(' ') };
+}
+exports.parseArgs = parseArgs;
+const getHelp = () => `
 DESCRIPTION:
-  A console program for quickly switching between branches
-
-OPTIONS:
-  help, -h, --h, --help
-    Showing this message
+  Quickly switch, merge, delete and synchronize Git branches.
 
-  -M, merge
-    Merge branch
+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
 
-  -sm, --show-merged
-    Showing merged branches
-
-  -un, --no-merged
-    Showing not merged branches
-
-  -D, rm
-    Delete the selected branch
+  Ctrl+C cancels and restores the previous terminal screen.
 `;
-};
 exports.getHelp = getHelp;

package/dist/commands/checkout-branch.js

@@ -2,15 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkoutBranch = void 0;
 const exec_1 = require("./exec");
-const color_1 = require("../color");
-//
+const terminal_1 = require("../terminal");
 async function checkoutBranch(branchName) {
-    if (!branchName) {
-        throw new Error('No branch...');
-    }
-    const checkoutCommand = `git checkout ${branchName}`;
-    console.log(' ' + color_1.clc.green('git checkout', branchName) + '\n');
-    const checkoutCommandResult = await (0, exec_1.exec)(checkoutCommand);
-    console.log(checkoutCommandResult);
+    if (!branchName)
+        throw new Error('No branch selected.');
+    (0, terminal_1.print)('git checkout ' + branchName);
+    (0, terminal_1.print)(await (0, exec_1.exec)(['checkout', branchName, '--']));
 }
 exports.checkoutBranch = checkoutBranch;

package/dist/commands/delete-barnch.d.ts

@@ -1 +1,2 @@
+export declare function deleteBranches(branchNames: string[], confirm?: boolean, force?: boolean): Promise<void>;
 export declare function deleteBranch(branchName: string): Promise<void>;

package/dist/commands/delete-barnch.js

@@ -1,30 +1,41 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteBranch = void 0;
-const inquirer_1 = __importDefault(require("inquirer"));
+exports.deleteBranch = exports.deleteBranches = void 0;
+const prompt_1 = require("../prompt");
 const exec_1 = require("./exec");
-const color_1 = require("../color");
-async function deleteBranch(branchName) {
-    if (!branchName) {
-        throw new Error('No branch...');
+const terminal_1 = require("../terminal");
+async function deleteBranches(branchNames, confirm = true, force = true) {
+    const branches = [...new Set(branchNames)];
+    if (!branches.length || branches.some(branch => !branch)) {
+        throw new Error('No branches selected.');
+    }
+    if (confirm) {
+        const { answer } = await (0, prompt_1.prompt)({
+            type: 'confirm',
+            name: 'answer',
+            message: 'Delete these branches: ' + branches.join(', ') + '?',
+            default: false,
+        });
+        if (!answer) {
+            (0, terminal_1.print)('Branches were not deleted.');
+            return;
+        }
     }
-    const res = await inquirer_1.default.prompt({
-        type: 'confirm',
-        name: 'answer',
-        message: color_1.clc.yellow('Are you sure you want to delete the branch "') + color_1.clc.red(branchName) + color_1.clc.yellow('"?'),
-        default: false,
-    });
-    if (res.answer === true) {
-        const command = `git branch -D ${branchName}`;
-        console.log(' ' + color_1.clc.redBg(`git branch -D ${branchName}`, '') + '\n');
-        const checkoutCommandResult = await (0, exec_1.exec)(command);
-        console.log(checkoutCommandResult);
-        console.log(color_1.clc.yellow('Branch'), color_1.clc.red(branchName), color_1.clc.yellow('has been deleted'));
-        return;
+    // Attempt every selected branch and report partial failures as well.
+    const errors = [];
+    for (const branch of branches) {
+        try {
+            (0, terminal_1.print)(await (0, exec_1.exec)(['branch', force ? '-D' : '-d', '--', branch]));
+        }
+        catch (error) {
+            errors.push(branch + ': ' + (error instanceof Error ? error.message : String(error)));
+        }
     }
-    console.log(color_1.clc.yellow('The branch was not deleted'));
+    if (errors.length)
+        throw new Error(errors.join('\n'));
+}
+exports.deleteBranches = deleteBranches;
+async function deleteBranch(branchName) {
+    return deleteBranches([branchName]);
 }
 exports.deleteBranch = deleteBranch;

package/dist/commands/exec.d.ts

@@ -1 +1 @@
-export declare function exec(command: any): Promise<string>;
+export declare function exec(args: string[]): Promise<string>;

package/dist/commands/exec.js

@@ -2,7 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exec = void 0;
 const child_process_1 = require("child_process");
-function exec(command) {
-    return new Promise((resolve, reject) => (0, child_process_1.exec)(command, (err, stdout) => err ? reject(err) : resolve(stdout)));
+function exec(args) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.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'));
+            }
+        });
+    });
 }
 exports.exec = exec;

package/dist/commands/get-branches.d.ts

@@ -3,7 +3,5 @@ export declare enum BranchesType {
     Merged = 1,
     NotMerged = 2
 }
-/**
- * get branch list
- */
-export declare function getBranches(type: BranchesType): Promise<string[]>;
+/** Remote origin refs are also offered for checkout/merge; deletion is local only. */
+export declare function getBranches(type: BranchesType, localOnly?: boolean): Promise<string[]>;

package/dist/commands/get-branches.js

@@ -8,40 +8,23 @@ var BranchesType;
     BranchesType[BranchesType["Merged"] = 1] = "Merged";
     BranchesType[BranchesType["NotMerged"] = 2] = "NotMerged";
 })(BranchesType = exports.BranchesType || (exports.BranchesType = {}));
-const commandsForGetBranches = {
-    [BranchesType.All]: 'git branch --all',
-    [BranchesType.Merged]: 'git branch --all --merged',
-    [BranchesType.NotMerged]: 'git branch --all --no-merged',
-};
-/**
- * get branch list
- */
-function getBranches(type) {
-    const command = commandsForGetBranches[type];
-    return (0, exec_1.exec)(command)
-        .then(parseBranches)
-        .then(branches => {
-        if (branches.length) {
-            return branches;
-        }
-        throw new Error('No branches found...');
-    });
+/** Remote origin refs are also offered for checkout/merge; deletion is local only. */
+async function getBranches(type, localOnly = false) {
+    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 (0, exec_1.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;
 }
 exports.getBranches = getBranches;
-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;
-}

package/dist/commands/get-current-branch-name.d.ts

@@ -1 +1 @@
-export declare function getCurrentBranchName(): Promise<void>;
+export declare function getCurrentBranchName(): Promise<string>;

package/dist/commands/get-current-branch-name.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCurrentBranchName = void 0;
 const exec_1 = require("./exec");
 async function getCurrentBranchName() {
-    const currentBranchName = `git rev-parse --abbrev-ref HEAD`;
-    const stdout = await (0, exec_1.exec)(currentBranchName);
-    console.log(stdout);
+    return (await (0, exec_1.exec)(['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
 }
 exports.getCurrentBranchName = getCurrentBranchName;

package/dist/commands/merge-branch.js

@@ -1,44 +1,40 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeBranch = void 0;
 const exec_1 = require("./exec");
-const color_1 = require("../color");
-const inquirer_1 = __importDefault(require("inquirer"));
-//
+const get_current_branch_name_1 = require("./get-current-branch-name");
+const delete_barnch_1 = require("./delete-barnch");
+const terminal_1 = require("../terminal");
+const prompt_1 = require("../prompt");
 async function mergeBranch(branchName) {
-    if (!branchName) {
-        throw new Error('No branch...');
-    }
-    const currentBranch = await (0, exec_1.exec)('git rev-parse --abbrev-ref HEAD');
-    const message = [
-        color_1.clc._blue,
-        'Do you want to merge branch ',
-        color_1.clc._green,
-        branchName,
-        color_1.clc._blue,
-        ' into ',
-        color_1.clc._green,
-        currentBranch,
-        color_1.clc._blue,
-        '?',
-        color_1.clc._off,
-    ].join('');
-    const res = await inquirer_1.default.prompt({
+    if (!branchName)
+        throw new Error('No branch selected.');
+    const currentBranch = await (0, get_current_branch_name_1.getCurrentBranchName)();
+    if (branchName === currentBranch)
+        throw new Error('Cannot merge the current branch into itself.');
+    const { answer } = await (0, prompt_1.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(' ' + color_1.clc.green('git merge', branchName) + '\n');
-        const checkoutCommandResult = await (0, exec_1.exec)(checkoutCommand);
-        console.log(checkoutCommandResult);
+    if (!answer) {
+        (0, terminal_1.print)('Branch was not merged.');
         return;
     }
-    console.log(color_1.clc.yellow('The branch was not merged'));
+    (0, terminal_1.print)('git merge ' + branchName);
+    (0, terminal_1.print)(await (0, exec_1.exec)(['merge', '--', branchName]));
+    // Only local branches can be deleted; never remove remote refs.
+    const locals = (await (0, exec_1.exec)(['for-each-ref', '--format=%(refname)', 'refs/heads/'])).split('\n');
+    if (!locals.includes('refs/heads/' + branchName))
+        return;
+    const { remove } = await (0, prompt_1.prompt)({
+        type: 'confirm',
+        name: 'remove',
+        message: 'Delete merged branch ' + branchName + '?',
+        default: true,
+    });
+    if (remove)
+        await (0, delete_barnch_1.deleteBranches)([branchName], false, false);
 }
 exports.mergeBranch = mergeBranch;

package/dist/commands/sync-branches.d.ts

@@ -0,0 +1,2 @@
+/** Synchronize local branches without switching branches or rewriting commits. */
+export declare function syncBranches(): Promise<void>;