avil13-co 2.2.5 → 2.4.0

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.d.ts

@@ -1 +1 @@
-export {};
+export declare const run: () => Promise<void>;

package/dist/index.js

@@ -1,34 +1,56 @@
 "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 sync_branches_1 = require("./commands/sync-branches");
+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;
+    if (command === cli_commands_1.Commands.Sync) {
+        (0, terminal_1.startTerminal)();
+        await (0, sync_branches_1.syncBranches)();
+        return;
     }
-    else if (cli_commands_1.Commands.ShowUnMerged === userWish) {
-        branchType = commands_1.BranchesType.NotMerged;
+    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.');
     }
-    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;
+    (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);
     }
-    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.4.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,31 @@
+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('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__/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__/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);
+});