avil13-co 2.3.0 → 2.4.0

package/README.md

@@ -1,6 +1,6 @@
 # avil13/co
 
-Interactive Git branch checkout, merge and deletion.
+Interactive Git branch checkout, merge, deletion and synchronization.
 
 ![demo](assets/cli-demo.gif)
 
@@ -19,6 +19,7 @@ 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
 ```
 
@@ -41,6 +42,26 @@ 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,

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

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

package/dist/cli-commands/index.js

@@ -9,6 +9,7 @@ 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 = process.argv[2]) => {
     if (['help', '-h', '--h', '--help'].includes(firstArg))
@@ -17,6 +18,8 @@ const getWishOfUser = (firstArg = process.argv[2]) => {
         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))
@@ -31,6 +34,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 +45,14 @@ 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.
 
 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

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,7 @@ 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 { command, filter } = (0, cli_commands_1.parseArgs)();
@@ -13,6 +14,11 @@ const run = async () => {
         console.log((0, cli_commands_1.getHelp)());
         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.4.0",
   "description": "",
   "main": "dist/index.js",
   "public": true,

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

@@ -19,6 +19,12 @@ describe('arguments', () => {
   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__/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,14 @@ export enum Commands {
   MergeBranch = 4,
   ShowMerged = 8,
   ShowUnMerged = 16,
+  Sync = 32,
 }
 
 export const getWishOfUser = (firstArg = process.argv[2]): Commands => {
   if (['help', '-h', '--h', '--help'].includes(firstArg)) return Commands.Help;
   if (['-M', 'merge'].includes(firstArg)) return Commands.MergeBranch;
   if (['-D', 'rm'].includes(firstArg)) return Commands.DeleteBranch;
+  if (firstArg === '-p') return Commands.Sync;
   if (['m', '-sm', '--show-merged'].includes(firstArg)) return Commands.ShowMerged;
   if (['un', '-un', '--no-merged'].includes(firstArg)) return Commands.ShowUnMerged;
   return Commands.Unknown;
@@ -22,6 +24,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 +34,14 @@ 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.
 
 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

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,7 @@ 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 { finishTerminal, installInterruptHandler, print, startTerminal } from './terminal';
 
 export const run = async () => {
@@ -12,6 +13,12 @@ export const run = async () => {
     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;