avil13-co 2.3.0 → 2.5.0

package/README.md

@@ -1,6 +1,6 @@
 # avil13/co
 
-Interactive Git branch checkout, merge and deletion.
+Interactive Git branch checkout, merge, deletion, synchronization and stash management.
 
 ![demo](assets/cli-demo.gif)
 
@@ -19,6 +19,8 @@ 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 -s               # List and manage stashes (also: --stash)
 co -h               # Show help
 ```
 
@@ -41,6 +43,42 @@ 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.
 
+### Stash
+
+`co -s` or `co --stash` lists stash entries, newest first, with their dates and
+messages. Select an entry to see its creation date, author, commit hash and
+change statistics (including untracked files saved in the stash).
+
+Choose **Apply** to restore changes and keep the stash, **Pop** to restore and
+remove it on success, or **Delete** to remove it without applying. Deletion asks
+for confirmation `[n/Y]`: Enter confirms, `n` cancels. A failed pop keeps the
+stash, including when Git reports conflicts. Git errors end the command with
+exit code 1; resolve any conflicts before trying again.
+
+Use **Back to stash list** to select another entry, or **Exit** to leave without
+changes. The list refreshes after deletion. Optional filtering is supported:
+`co -s - search text` matches the reference, date or message.
+
+### 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,

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

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

package/dist/cli-commands/index.js

@@ -9,6 +9,8 @@ var Commands;
     Commands[Commands["MergeBranch"] = 4] = "MergeBranch";
     Commands[Commands["ShowMerged"] = 8] = "ShowMerged";
     Commands[Commands["ShowUnMerged"] = 16] = "ShowUnMerged";
+    Commands[Commands["Sync"] = 32] = "Sync";
+    Commands[Commands["Stash"] = 64] = "Stash";
 })(Commands = exports.Commands || (exports.Commands = {}));
 const getWishOfUser = (firstArg = process.argv[2]) => {
     if (['help', '-h', '--h', '--help'].includes(firstArg))
@@ -17,6 +19,10 @@ const getWishOfUser = (firstArg = process.argv[2]) => {
         return Commands.MergeBranch;
     if (['-D', 'rm'].includes(firstArg))
         return Commands.DeleteBranch;
+    if (firstArg === '-p')
+        return Commands.Sync;
+    if (['-s', '--stash'].includes(firstArg))
+        return Commands.Stash;
     if (['m', '-sm', '--show-merged'].includes(firstArg))
         return Commands.ShowMerged;
     if (['un', '-un', '--no-merged'].includes(firstArg))
@@ -31,6 +37,9 @@ function parseArgs(args = process.argv.slice(2)) {
     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();
@@ -39,13 +48,15 @@ function parseArgs(args = process.argv.slice(2)) {
 exports.parseArgs = parseArgs;
 const getHelp = () => `
 DESCRIPTION:
-  Quickly switch, merge and delete Git branches.
+  Quickly switch, merge, delete and synchronize Git branches, and manage stashes.
 
 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 -s, --stash [- filter] List stashes, view details, apply, pop or delete [n/Y]
   co m, -sm, --show-merged   Show merged branches
   co un, -un, --no-merged    Show unmerged branches
   co help, -h, --h, --help   Show this message

package/dist/commands/stash.d.ts

@@ -0,0 +1,12 @@
+export interface StashEntry {
+    ref: string;
+    hash: string;
+    date: string;
+    author: string;
+    message: string;
+}
+export declare function getStashes(): Promise<StashEntry[]>;
+export declare function showStash(entry: StashEntry): Promise<void>;
+export declare function applyStash(entry: StashEntry, pop?: boolean): Promise<void>;
+export declare function dropStash(entry: StashEntry): Promise<boolean>;
+export declare function manageStashes(filter?: string): Promise<void>;

package/dist/commands/stash.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageStashes = exports.dropStash = exports.applyStash = exports.showStash = exports.getStashes = void 0;
+const ask_1 = require("../ask");
+const color_1 = require("../color");
+const prompt_1 = require("../prompt");
+const terminal_1 = require("../terminal");
+const exec_1 = require("./exec");
+async function getStashes() {
+    const output = await (0, exec_1.exec)(['stash', 'list', '--format=%gd%x00%H%x00%cI%x00%an%x00%gs']);
+    if (!output)
+        return [];
+    return output.split('\n').map(line => {
+        const [ref, hash, date, author, message] = line.split('\0');
+        return { ref, hash, date, author, message };
+    });
+}
+exports.getStashes = getStashes;
+async function assertStash(entry) {
+    // Reflog indices can shift if another process changes the stash list.
+    const hash = await (0, exec_1.exec)(['rev-parse', '--verify', entry.ref]);
+    if (hash !== entry.hash)
+        throw new Error('Stash list changed. Run co --stash again.');
+}
+async function showStash(entry) {
+    await assertStash(entry);
+    const details = `${entry.ref}: ${entry.message}\nDate: ${entry.date}\nAuthor: ${entry.author}\nCommit: ${entry.hash}`;
+    const stats = await (0, exec_1.exec)(['stash', 'show', '--stat', '--include-untracked', '--no-color', entry.hash]);
+    const output = [details, stats].filter(Boolean).join('\n');
+    (0, terminal_1.print)(process.stdout.isTTY ? color_1.clc.gray(output) : output);
+}
+exports.showStash = showStash;
+async function applyStash(entry, pop = false) {
+    await assertStash(entry);
+    // Let Git perform pop: on conflicts it preserves the stash automatically.
+    (0, terminal_1.print)(await (0, exec_1.exec)(['stash', pop ? 'pop' : 'apply', entry.ref]));
+    (0, terminal_1.print)(`${entry.ref}: ${pop ? 'popped' : 'applied (stash kept)'}.`);
+}
+exports.applyStash = applyStash;
+async function dropStash(entry) {
+    const { answer } = await (0, prompt_1.prompt)({
+        type: 'input',
+        name: 'answer',
+        message: `Delete ${entry.ref}: ${entry.message}? [n/Y]`,
+        default: 'Y',
+        filter: (value) => value.trim().toLowerCase(),
+        validate: (value) => ['n', 'y'].includes(value) || 'Enter n or Y.',
+    });
+    if (answer.toLowerCase() !== 'y') {
+        (0, terminal_1.print)('Stash was not deleted.');
+        return false;
+    }
+    await assertStash(entry);
+    (0, terminal_1.print)(await (0, exec_1.exec)(['stash', 'drop', entry.ref]));
+    return true;
+}
+exports.dropStash = dropStash;
+async function manageStashes(filter = '') {
+    while (true) {
+        const entries = await getStashes();
+        if (!entries.length) {
+            (0, terminal_1.print)('No stash entries.');
+            return;
+        }
+        const filtered = entries.filter(entry => (0, ask_1.checkItem)(`${entry.ref} ${entry.date} ${entry.message}`, filter));
+        if (!filtered.length) {
+            (0, terminal_1.print)('No stash entries match the filter.');
+            return;
+        }
+        const { entry } = await (0, prompt_1.prompt)({
+            type: 'list',
+            name: 'entry',
+            message: 'Select stash',
+            choices: [
+                ...filtered.map(value => ({ name: `📦 ${value.ref} | ${value.date} | ${value.message}`, value })),
+                { name: '🚪 Exit', value: null },
+            ],
+        });
+        if (!entry)
+            return;
+        await showStash(entry);
+        const { action } = await (0, prompt_1.prompt)({
+            type: 'list',
+            name: 'action',
+            message: `Action for ${entry.ref}`,
+            choices: [
+                { name: '⬅️ Back to stash list', value: 'back' },
+                { name: '📥 Apply (keep stash)', value: 'apply' },
+                { name: '📤 Pop (apply and remove on success)', value: 'pop' },
+                { name: '🗑️ Delete stash', value: 'drop' },
+                { name: '🚪 Exit', value: 'exit' },
+            ],
+        });
+        if (action === 'exit')
+            return;
+        if (action === 'apply' || action === 'pop') {
+            await applyStash(entry, action === 'pop');
+            return;
+        }
+        if (action === 'drop')
+            await dropStash(entry);
+    }
+}
+exports.manageStashes = manageStashes;

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>;

package/dist/commands/sync-branches.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncBranches = void 0;
+const exec_1 = require("./exec");
+const get_current_branch_name_1 = require("./get-current-branch-name");
+const terminal_1 = require("../terminal");
+/** Synchronize local branches without switching branches or rewriting commits. */
+async function syncBranches() {
+    const remotes = (await (0, exec_1.exec)(['remote'])).split('\n').filter(Boolean);
+    if (!remotes.length)
+        throw new Error('No remotes configured. Add a Git remote before running co -p.');
+    (0, terminal_1.print)('Fetching all remotes...');
+    (0, terminal_1.print)(await (0, exec_1.exec)(['fetch', '--all', '--prune']));
+    const refs = new Map((await (0, exec_1.exec)(['for-each-ref', '--format=%(refname)%09%(objectname)']))
+        .split('\n').filter(Boolean).map(line => {
+        const [ref, oid] = line.split('\t');
+        return [ref, oid];
+    }));
+    const branches = (await (0, exec_1.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 (0, get_current_branch_name_1.getCurrentBranchName)();
+    const checkedOut = new Set((await (0, exec_1.exec)(['worktree', 'list', '--porcelain', '-z']))
+        .split('\0').filter(field => field.startsWith('branch ')).map(field => field.slice(7)));
+    const dirty = Boolean(await (0, exec_1.exec)(['status', '--porcelain']));
+    const stale = [];
+    const errors = [];
+    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 {
+                    (0, terminal_1.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
+                    (0, terminal_1.print)(branch.name + ': skipped (upstream is missing).');
+                continue;
+            }
+            const [ahead, behind] = (await (0, exec_1.exec)(['rev-list', '--left-right', '--count', branch.oid + '...' + target]))
+                .split(/\s+/).map(Number);
+            if (ahead) {
+                (0, terminal_1.print)(branch.name + ': warning: ' + ahead + ' unpushed commit(s)' +
+                    (behind ? ', diverged from upstream by ' + behind + ' commit(s)' : '') + '; kept unchanged.');
+            }
+            else if (!behind) {
+                (0, terminal_1.print)(branch.name + ': up to date.');
+            }
+            else if (checkedOut.has(branch.ref) && branch.ref !== current) {
+                (0, terminal_1.print)(branch.name + ': skipped (checked out in another worktree).');
+            }
+            else if (branch.ref === current && dirty) {
+                (0, terminal_1.print)(branch.name + ': skipped (working tree has uncommitted changes).');
+            }
+            else {
+                if (branch.ref === current) {
+                    (0, terminal_1.print)(await (0, exec_1.exec)(['merge', '--ff-only', '--no-edit', '--', target]));
+                }
+                else {
+                    // Compare-and-swap protects against concurrent changes to the local ref.
+                    await (0, exec_1.exec)(['update-ref', '-m', 'co sync: fast-forward', branch.ref, target, branch.oid]);
+                }
+                (0, terminal_1.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)) {
+                (0, terminal_1.print)(branch.name + ': kept (upstream deleted, branch is checked out).');
+            }
+            else if (await (0, exec_1.exec)(['rev-list', '--count', branch.oid, '--not', 'HEAD']) !== '0') {
+                (0, terminal_1.print)(branch.name + ': warning: upstream deleted, unmerged commits kept.');
+            }
+            else {
+                (0, terminal_1.print)(await (0, exec_1.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'));
+}
+exports.syncBranches = syncBranches;

package/dist/index.js

@@ -6,6 +6,8 @@ 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 sync_branches_1 = require("./commands/sync-branches");
+const stash_1 = require("./commands/stash");
 const terminal_1 = require("./terminal");
 const run = async () => {
     const { command, filter } = (0, cli_commands_1.parseArgs)();
@@ -13,6 +15,16 @@ const run = async () => {
         console.log((0, cli_commands_1.getHelp)());
         return;
     }
+    if (command === cli_commands_1.Commands.Stash) {
+        (0, terminal_1.startTerminal)();
+        await (0, stash_1.manageStashes)(filter);
+        return;
+    }
+    if (command === cli_commands_1.Commands.Sync) {
+        (0, terminal_1.startTerminal)();
+        await (0, sync_branches_1.syncBranches)();
+        return;
+    }
     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;

package/package.json

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

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

@@ -19,6 +19,16 @@ describe('arguments', () => {
   it.each(['un', '-un', '--no-merged'])('accepts unmerged alias %s', alias => {
     expect(parseArgs([alias]).command).toBe(Commands.ShowUnMerged);
   });
+  it.each(['-s', '--stash'])('accepts stash alias %s and optional filter', alias => {
+    expect(parseArgs([alias])).toEqual({ command: Commands.Stash, filter: '' });
+    expect(parseArgs([alias, '-', 'work'])).toEqual({ command: Commands.Stash, filter: 'work' });
+  });
+  it('accepts sync without a filter', () => {
+    expect(parseArgs(['-p'])).toEqual({ command: Commands.Sync, filter: '' });
+  });
+  it('rejects a filter for sync instead of silently ignoring it', () => {
+    expect(() => parseArgs(['-p', '-', '1234'])).toThrow('does not accept a filter');
+  });
   it('reports unknown options', () => {
     expect(() => parseArgs(['--typo'])).toThrow('Unknown option');
   });

package/src/__tests__/stash.spec.ts

@@ -0,0 +1,171 @@
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { execFileSync } from 'child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import inquirer from 'inquirer';
+import { applyStash, dropStash, getStashes, manageStashes, showStash } from '../commands/stash';
+
+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', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+}
+function stash(message = 'saved work') {
+  writeFileSync(join(context.cwd, 'file.txt'), message);
+  git('stash', 'push', '-qm', message);
+}
+
+beforeEach(() => {
+  context.cwd = mkdtempSync(join(tmpdir(), 'co-stash-'));
+  git('init', '-q', '-b', 'main');
+  git('config', 'user.name', 'Test');
+  git('config', 'user.email', 'test@example.test');
+  writeFileSync(join(context.cwd, 'file.txt'), 'initial');
+  git('add', '.');
+  git('commit', '-qm', 'initial');
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+});
+afterEach(() => {
+  vi.restoreAllMocks();
+  rmSync(context.cwd, { recursive: true, force: true });
+});
+
+it('handles an empty stash list without prompting', async () => {
+  const prompt = vi.spyOn(inquirer, 'prompt');
+  expect(await getStashes()).toEqual([]);
+  await manageStashes();
+  expect(prompt).not.toHaveBeenCalled();
+  expect(console.log).toHaveBeenCalledWith('No stash entries.');
+});
+
+it('lists newest first with references, dates, author and literal messages', async () => {
+  stash('older');
+  stash('new; $(echo nope) | message');
+  const entries = await getStashes();
+  expect(entries).toHaveLength(2);
+  expect(entries[0]).toMatchObject({ ref: 'stash@{0}', author: 'Test', message: 'On main: new; $(echo nope) | message' });
+  expect(entries[0].hash).toBe(git('rev-parse', 'stash@{0}'));
+  expect(Number.isNaN(Date.parse(entries[0].date))).toBe(false);
+  expect(entries[1].ref).toBe('stash@{1}');
+});
+
+it('shows metadata and tracked and untracked file statistics', async () => {
+  writeFileSync(join(context.cwd, 'file.txt'), 'changed');
+  writeFileSync(join(context.cwd, 'extra.txt'), 'untracked');
+  git('stash', 'push', '-qu', '-m', 'details');
+  const [entry] = await getStashes();
+  await showStash(entry);
+  expect(console.log).toHaveBeenCalledWith(expect.stringContaining(`Commit: ${entry.hash}`));
+  expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/extra.txt[\s\S]*file.txt/));
+});
+
+it('renders stash details and statistics in gray in a terminal', async () => {
+  stash();
+  const descriptor = Object.getOwnPropertyDescriptor(process.stdout, 'isTTY');
+  Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
+  try {
+    await showStash((await getStashes())[0]);
+    expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/^\x1b\[0;90m[\s\S]*file.txt[\s\S]*\x1b\[0m$/));
+  } finally {
+    if (descriptor) Object.defineProperty(process.stdout, 'isTTY', descriptor);
+    else delete (process.stdout as any).isTTY;
+  }
+});
+
+it.each([false, true])('applies changes with pop=%s and keeps/removes the stash', async pop => {
+  stash();
+  await applyStash((await getStashes())[0], pop);
+  expect(readFileSync(join(context.cwd, 'file.txt'), 'utf8')).toBe('saved work');
+  expect(await getStashes()).toHaveLength(pop ? 0 : 1);
+});
+
+it('keeps the stash when pop has conflicts', async () => {
+  stash();
+  writeFileSync(join(context.cwd, 'file.txt'), 'conflicting commit');
+  git('add', '.');
+  git('commit', '-qm', 'conflict');
+  await expect(applyStash((await getStashes())[0], true)).rejects.toThrow();
+  expect(await getStashes()).toHaveLength(1);
+  expect(git('status', '--porcelain')).toContain('UU file.txt');
+});
+
+it('does not drop a stash if confirmation is declined', async () => {
+  stash();
+  const prompt = vi.spyOn(inquirer, 'prompt').mockResolvedValue({ answer: 'n' });
+  expect(await dropStash((await getStashes())[0])).toBe(false);
+  expect(await getStashes()).toHaveLength(1);
+  expect(prompt).toHaveBeenCalledWith(expect.objectContaining({ default: 'Y', message: expect.stringContaining('[n/Y]') }));
+});
+
+it('drops only the selected stash after confirmation', async () => {
+  stash('older');
+  stash('newer');
+  vi.spyOn(inquirer, 'prompt').mockResolvedValue({ answer: 'Y' });
+  expect(await dropStash((await getStashes())[1])).toBe(true);
+  expect((await getStashes()).map(entry => entry.message)).toEqual(['On main: newer']);
+});
+
+it('refuses to act on an entry whose index has changed', async () => {
+  stash('older');
+  const [entry] = await getStashes();
+  stash('newer');
+  vi.spyOn(inquirer, 'prompt').mockResolvedValue({ answer: 'y' });
+  await expect(dropStash(entry)).rejects.toThrow('Stash list changed');
+  await expect(applyStash(entry)).rejects.toThrow('Stash list changed');
+  expect(await getStashes()).toHaveLength(2);
+});
+
+it('refreshes the list after deletion and permits exiting', async () => {
+  stash('older');
+  stash('newer');
+  const [entry] = await getStashes();
+  const prompt = vi.spyOn(inquirer, 'prompt')
+    .mockResolvedValueOnce({ entry })
+    .mockResolvedValueOnce({ action: 'drop' })
+    .mockResolvedValueOnce({ answer: 'y' })
+    .mockResolvedValueOnce({ entry: null });
+  await manageStashes();
+  const choices = (prompt.mock.calls[3][0] as any).choices;
+  expect(choices).toHaveLength(2);
+  expect(choices[0].value).toMatchObject({ ref: 'stash@{0}', message: 'On main: older' });
+});
+
+it('filters the selection and allows backing out without changes', async () => {
+  stash('older');
+  stash('newer');
+  const entry = (await getStashes())[1];
+  const prompt = vi.spyOn(inquirer, 'prompt')
+    .mockResolvedValueOnce({ entry })
+    .mockResolvedValueOnce({ action: 'back' })
+    .mockResolvedValueOnce({ entry: null });
+  await manageStashes('older');
+  expect((prompt.mock.calls[0][0] as any).choices).toHaveLength(2);
+  expect(await getStashes()).toHaveLength(2);
+});
+
+it('reports a filter with no matches without prompting', async () => {
+  stash();
+  const prompt = vi.spyOn(inquirer, 'prompt');
+  await manageStashes('missing');
+  expect(prompt).not.toHaveBeenCalled();
+  expect(console.log).toHaveBeenCalledWith('No stash entries match the filter.');
+});
+
+it.each(['apply', 'pop'])('runs the selected %s action', async action => {
+  stash();
+  const [entry] = await getStashes();
+  vi.spyOn(inquirer, 'prompt')
+    .mockResolvedValueOnce({ entry })
+    .mockResolvedValueOnce({ action });
+  await manageStashes();
+  expect(readFileSync(join(context.cwd, 'file.txt'), 'utf8')).toBe('saved work');
+  expect(await getStashes()).toHaveLength(action === 'pop' ? 0 : 1);
+});

package/src/__tests__/sync-branches.spec.ts

@@ -0,0 +1,223 @@
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { execFileSync } from 'child_process';
+import { mkdtempSync, rmSync, writeFileSync, readFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { syncBranches } from '../commands/sync-branches';
+
+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),
+  };
+});
+
+let root: string;
+let remote: string;
+let peer: string;
+function gitAt(cwd: string, ...args: string[]) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+}
+function git(...args: string[]) { return gitAt(context.cwd, ...args); }
+function other(...args: string[]) { return gitAt(peer, ...args); }
+function commit(cwd: string, text: string) {
+  writeFileSync(join(cwd, 'file.txt'), text);
+  gitAt(cwd, 'add', 'file.txt');
+  gitAt(cwd, 'commit', '-qm', text);
+}
+function publishFeature() {
+  other('checkout', '-qb', 'feature');
+  commit(peer, 'feature initial');
+  other('push', '-qu', 'origin', 'feature');
+  git('fetch', '-q');
+  git('branch', '--track', 'feature', 'origin/feature');
+}
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), 'co-sync-'));
+  context.cwd = join(root, 'work');
+  remote = join(root, 'remote.git');
+  peer = join(root, 'peer');
+  gitAt(root, 'init', '--bare', '-q', '-b', 'main', remote);
+  gitAt(root, 'init', '-q', '-b', 'main', context.cwd);
+  git('config', 'user.name', 'Test');
+  git('config', 'user.email', 'test@example.test');
+  commit(context.cwd, 'initial');
+  git('remote', 'add', 'origin', remote);
+  git('push', '-qu', 'origin', 'main');
+  gitAt(root, 'clone', '-q', remote, peer);
+  other('config', 'user.name', 'Test');
+  other('config', 'user.email', 'test@example.test');
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  rmSync(root, { recursive: true, force: true });
+});
+
+it('fetches and fast-forwards both current and inactive branches without switching', async () => {
+  publishFeature();
+  commit(peer, 'feature update');
+  other('push', '-q');
+  other('checkout', '-q', 'main');
+  commit(peer, 'main update');
+  other('push', '-q');
+
+  await syncBranches();
+
+  expect(git('rev-parse', 'main')).toBe(other('rev-parse', 'main'));
+  expect(git('rev-parse', 'feature')).toBe(other('rev-parse', 'feature'));
+  expect(git('branch', '--show-current')).toBe('main');
+  expect(readFileSync(join(context.cwd, 'file.txt'), 'utf8')).toBe('main update');
+});
+
+it('keeps unpushed commits', async () => {
+  commit(context.cwd, 'local work');
+  const before = git('rev-parse', 'HEAD');
+  await syncBranches();
+  expect(git('rev-parse', 'HEAD')).toBe(before);
+  expect(console.log).toHaveBeenCalledWith(expect.stringContaining('unpushed'));
+});
+
+it('does not merge or rebase diverged branches', async () => {
+  commit(context.cwd, 'local work');
+  commit(peer, 'remote work');
+  other('push', '-q');
+  const before = git('rev-parse', 'HEAD');
+  await syncBranches();
+  expect(git('rev-parse', 'HEAD')).toBe(before);
+  expect(console.log).toHaveBeenCalledWith(expect.stringContaining('diverged'));
+});
+
+it('preserves a dirty current working tree', async () => {
+  commit(peer, 'remote work');
+  other('push', '-q');
+  writeFileSync(join(context.cwd, 'file.txt'), 'uncommitted');
+  const before = git('rev-parse', 'HEAD');
+  await syncBranches();
+  expect(git('rev-parse', 'HEAD')).toBe(before);
+  expect(readFileSync(join(context.cwd, 'file.txt'), 'utf8')).toBe('uncommitted');
+  expect(console.log).toHaveBeenCalledWith(expect.stringContaining('uncommitted changes'));
+});
+
+it('uses a same-named remote branch without changing tracking configuration', async () => {
+  git('branch', '--unset-upstream', 'main');
+  commit(peer, 'remote update');
+  other('push', '-q');
+  await syncBranches();
+  expect(git('rev-parse', 'HEAD')).toBe(other('rev-parse', 'HEAD'));
+  expect(git('for-each-ref', '--format=%(upstream)', 'refs/heads/main')).toBe('');
+});
+
+it('deletes merged branches after fetching a deleted upstream', async () => {
+  git('branch', 'obsolete');
+  git('push', '-qu', 'origin', 'obsolete');
+  other('push', '-q', 'origin', '--delete', 'obsolete');
+  await syncBranches();
+  expect(git('branch', '--list', 'obsolete')).toBe('');
+  expect(git('branch', '--list', 'main')).toContain('main');
+});
+
+it('checks stale branches after fast-forwarding the current branch', async () => {
+  publishFeature();
+  other('checkout', '-q', 'main');
+  other('merge', '--ff-only', 'feature');
+  other('push', '-q');
+  other('push', '-q', 'origin', '--delete', 'feature');
+  await syncBranches();
+  expect(git('branch', '--list', 'feature')).toBe('');
+  expect(git('rev-parse', 'main')).toBe(other('rev-parse', 'main'));
+});
+
+it('keeps unmerged branches when their upstream is deleted', async () => {
+  publishFeature();
+  other('push', '-q', 'origin', '--delete', 'feature');
+  const before = git('rev-parse', 'feature');
+  await syncBranches();
+  expect(git('rev-parse', 'feature')).toBe(before);
+  expect(console.log).toHaveBeenCalledWith(expect.stringContaining('unmerged commits kept'));
+});
+
+it('never deletes the checked-out branch even if its upstream disappeared', async () => {
+  gitAt(remote, 'config', 'receive.denyDeleteCurrent', 'ignore');
+  other('push', '-q', 'origin', '--delete', 'main');
+  await syncBranches();
+  expect(git('branch', '--show-current')).toBe('main');
+  expect(console.log).toHaveBeenCalledWith(expect.stringContaining('branch is checked out'));
+});
+
+it('does not update branches checked out in another worktree', async () => {
+  publishFeature();
+  const worktree = join(root, 'linked');
+  git('worktree', 'add', '-q', worktree, 'feature');
+  const before = git('rev-parse', 'feature');
+  commit(peer, 'remote feature update');
+  other('push', '-q');
+  await syncBranches();
+  expect(git('rev-parse', 'feature')).toBe(before);
+  expect(readFileSync(join(worktree, 'file.txt'), 'utf8')).toBe('feature initial');
+  expect(console.log).toHaveBeenCalledWith(expect.stringContaining('another worktree'));
+});
+
+it('skips local-only branches', async () => {
+  git('branch', '--no-track', 'local-only');
+  await syncBranches();
+  expect(git('branch', '--list', 'local-only')).toContain('local-only');
+  expect(console.log).toHaveBeenCalledWith('local-only: skipped (no upstream).');
+});
+
+it('uses a unique same-named branch on a non-origin remote', async () => {
+  git('remote', 'rename', 'origin', 'upstream');
+  git('branch', '--unset-upstream', 'main');
+  commit(peer, 'remote update');
+  other('push', '-q');
+  await syncBranches();
+  expect(git('rev-parse', 'HEAD')).toBe(other('rev-parse', 'HEAD'));
+});
+
+it('does not guess between multiple matching remotes without origin', async () => {
+  git('remote', 'rename', 'origin', 'one');
+  git('remote', 'add', 'two', remote);
+  git('branch', '--unset-upstream', 'main');
+  commit(peer, 'remote update');
+  other('push', '-q');
+  const before = git('rev-parse', 'HEAD');
+  await syncBranches();
+  expect(git('rev-parse', 'HEAD')).toBe(before);
+  expect(console.log).toHaveBeenCalledWith('main: skipped (ambiguous upstream).');
+});
+
+it('can update local branches while HEAD is detached without touching the worktree', async () => {
+  git('checkout', '--detach', '-q');
+  const before = git('rev-parse', 'HEAD');
+  commit(peer, 'remote update');
+  other('push', '-q');
+  await syncBranches();
+  expect(git('rev-parse', 'main')).toBe(other('rev-parse', 'main'));
+  expect(git('rev-parse', 'HEAD')).toBe(before);
+  expect(readFileSync(join(context.cwd, 'file.txt'), 'utf8')).toBe('initial');
+});
+
+it('keeps merged stale branches checked out in other worktrees', async () => {
+  git('branch', 'obsolete');
+  git('push', '-qu', 'origin', 'obsolete');
+  git('worktree', 'add', '-q', join(root, 'linked'), 'obsolete');
+  other('push', '-q', 'origin', '--delete', 'obsolete');
+  await syncBranches();
+  expect(git('branch', '--list', 'obsolete')).toContain('obsolete');
+});
+
+it('fails clearly when there are no remotes', async () => {
+  git('remote', 'remove', 'origin');
+  await expect(syncBranches()).rejects.toThrow('No remotes configured');
+});
+
+it('does not change branches if fetching fails', async () => {
+  git('remote', 'set-url', 'origin', join(root, 'missing.git'));
+  const before = git('show-ref');
+  await expect(syncBranches()).rejects.toThrow();
+  expect(git('show-ref')).toBe(before);
+});

package/src/cli-commands/index.ts

@@ -5,12 +5,16 @@ export enum Commands {
   MergeBranch = 4,
   ShowMerged = 8,
   ShowUnMerged = 16,
+  Sync = 32,
+  Stash = 64,
 }
 
 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 (['-s', '--stash'].includes(firstArg)) return Commands.Stash;
   if (['m', '-sm', '--show-merged'].includes(firstArg)) return Commands.ShowMerged;
   if (['un', '-un', '--no-merged'].includes(firstArg)) return Commands.ShowUnMerged;
   return Commands.Unknown;
@@ -22,6 +26,9 @@ export function parseArgs(args = process.argv.slice(2)) {
   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(' ') };
@@ -29,13 +36,15 @@ export function parseArgs(args = process.argv.slice(2)) {
 
 export const getHelp = (): string => `
 DESCRIPTION:
-  Quickly switch, merge and delete Git branches.
+  Quickly switch, merge, delete and synchronize Git branches, and manage stashes.
 
 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 -s, --stash [- filter] List stashes, view details, apply, pop or delete [n/Y]
   co m, -sm, --show-merged   Show merged branches
   co un, -un, --no-merged    Show unmerged branches
   co help, -h, --h, --help   Show this message

package/src/commands/stash.ts

@@ -0,0 +1,105 @@
+import { checkItem } from '../ask';
+import { clc } from '../color';
+import { prompt } from '../prompt';
+import { print } from '../terminal';
+import { exec } from './exec';
+
+export interface StashEntry {
+  ref: string;
+  hash: string;
+  date: string;
+  author: string;
+  message: string;
+}
+
+export async function getStashes(): Promise<StashEntry[]> {
+  const output = await exec(['stash', 'list', '--format=%gd%x00%H%x00%cI%x00%an%x00%gs']);
+  if (!output) return [];
+  return output.split('\n').map(line => {
+    const [ref, hash, date, author, message] = line.split('\0');
+    return { ref, hash, date, author, message };
+  });
+}
+
+async function assertStash(entry: StashEntry) {
+  // Reflog indices can shift if another process changes the stash list.
+  const hash = await exec(['rev-parse', '--verify', entry.ref]);
+  if (hash !== entry.hash) throw new Error('Stash list changed. Run co --stash again.');
+}
+
+export async function showStash(entry: StashEntry) {
+  await assertStash(entry);
+  const details = `${entry.ref}: ${entry.message}\nDate: ${entry.date}\nAuthor: ${entry.author}\nCommit: ${entry.hash}`;
+  const stats = await exec(['stash', 'show', '--stat', '--include-untracked', '--no-color', entry.hash]);
+  const output = [details, stats].filter(Boolean).join('\n');
+  print(process.stdout.isTTY ? clc.gray(output) : output);
+}
+
+export async function applyStash(entry: StashEntry, pop = false) {
+  await assertStash(entry);
+  // Let Git perform pop: on conflicts it preserves the stash automatically.
+  print(await exec(['stash', pop ? 'pop' : 'apply', entry.ref]));
+  print(`${entry.ref}: ${pop ? 'popped' : 'applied (stash kept)'}.`);
+}
+
+export async function dropStash(entry: StashEntry): Promise<boolean> {
+  const { answer } = await prompt<{ answer: string }>({
+    type: 'input',
+    name: 'answer',
+    message: `Delete ${entry.ref}: ${entry.message}? [n/Y]`,
+    default: 'Y',
+    filter: (value: string) => value.trim().toLowerCase(),
+    validate: (value: string) => ['n', 'y'].includes(value) || 'Enter n or Y.',
+  });
+  if (answer.toLowerCase() !== 'y') {
+    print('Stash was not deleted.');
+    return false;
+  }
+  await assertStash(entry);
+  print(await exec(['stash', 'drop', entry.ref]));
+  return true;
+}
+
+export async function manageStashes(filter = '') {
+  while (true) {
+    const entries = await getStashes();
+    if (!entries.length) {
+      print('No stash entries.');
+      return;
+    }
+    const filtered = entries.filter(entry => checkItem(`${entry.ref} ${entry.date} ${entry.message}`, filter));
+    if (!filtered.length) {
+      print('No stash entries match the filter.');
+      return;
+    }
+    const { entry } = await prompt<{ entry: StashEntry | null }>({
+      type: 'list',
+      name: 'entry',
+      message: 'Select stash',
+      choices: [
+        ...filtered.map(value => ({ name: `📦 ${value.ref} | ${value.date} | ${value.message}`, value })),
+        { name: '🚪 Exit', value: null },
+      ],
+    });
+    if (!entry) return;
+    await showStash(entry);
+    const { action } = await prompt<{ action: string }>({
+      type: 'list',
+      name: 'action',
+      message: `Action for ${entry.ref}`,
+      choices: [
+        { name: '⬅️ Back to stash list', value: 'back' },
+        { name: '📥 Apply (keep stash)', value: 'apply' },
+        { name: '📤 Pop (apply and remove on success)', value: 'pop' },
+        { name: '🗑️ Delete stash', value: 'drop' },
+        { name: '🚪 Exit', value: 'exit' },
+      ],
+    });
+    if (action === 'exit') return;
+    if (action === 'apply' || action === 'pop') {
+      await applyStash(entry, action === 'pop');
+      return;
+    }
+    if (action === 'drop') await dropStash(entry);
+  }
+}

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'));
+}

package/src/index.ts

@@ -3,6 +3,8 @@ import { Commands, getHelp, parseArgs } from './cli-commands';
 import { BranchesType, checkoutBranch, getBranches, getCurrentBranchName } from './commands';
 import { deleteBranches } from './commands/delete-barnch';
 import { mergeBranch } from './commands/merge-branch';
+import { syncBranches } from './commands/sync-branches';
+import { manageStashes } from './commands/stash';
 import { finishTerminal, installInterruptHandler, print, startTerminal } from './terminal';
 
 export const run = async () => {
@@ -12,6 +14,18 @@ export const run = async () => {
     return;
   }
 
+  if (command === Commands.Stash) {
+    startTerminal();
+    await manageStashes(filter);
+    return;
+  }
+
+  if (command === Commands.Sync) {
+    startTerminal();
+    await syncBranches();
+    return;
+  }
+
   const branchType = command === Commands.ShowMerged ? BranchesType.Merged
     : command === Commands.ShowUnMerged ? BranchesType.NotMerged : BranchesType.All;
   const deleting = command === Commands.DeleteBranch;