fix: sync against local base branch by default instead of upstream

Author: nigel-dev

src/lib/providers/worktree-provider.ts

@@ -57,5 +57,5 @@ export interface WorktreeProvider {
    * Sync a worktree with the base branch using the specified strategy.
    * Returns success status and any conflicts.
    */
-  sync(path: string, strategy: 'rebase' | 'merge', baseBranch?: string): Promise<SyncResult>;
+  sync(path: string, strategy: 'rebase' | 'merge', baseBranch?: string, source?: 'local' | 'origin'): Promise<SyncResult>;
 }

src/lib/worktree.ts

@@ -1,7 +1,7 @@
 import { spawn } from 'bun';
 import { join, resolve } from 'path';
 import { getProjectId, getXdgDataDir } from './paths';
-import { gitCommand } from './git';
+import { gitCommand, getDefaultBranch } from './git';
 import type {
   WorktreeInfo,
   SyncResult,
@@ -222,30 +222,23 @@ export async function syncWorktree(
   path: string,
   strategy: 'rebase' | 'merge',
   baseBranch?: string,
+  source?: 'local' | 'origin',
 ): Promise<SyncResult> {
   let targetBranch: string;
   if (baseBranch) {
-    targetBranch = `origin/${baseBranch}`;
+    const useOrigin = source === 'origin' || (!source);
+    targetBranch = useOrigin ? `origin/${baseBranch}` : baseBranch;
   } else {
-    const upstreamResult = await gitCommand(
-      ['-C', path, 'rev-parse', '--abbrev-ref', 'HEAD@{upstream}'],
-    );
-
-    if (upstreamResult.exitCode !== 0) {
-      const defaultBranchResult = await gitCommand([
-        'symbolic-ref',
-        '--short',
-        'refs/remotes/origin/HEAD',
-      ]);
-      targetBranch = defaultBranchResult.stdout || 'main';
-    } else {
-      targetBranch = upstreamResult.stdout;
-    }
+    const defaultBranch = await getDefaultBranch();
+    const useOrigin = source === 'origin';
+    targetBranch = useOrigin ? `origin/${defaultBranch}` : defaultBranch;
   }
 
-  const fetchResult = await gitCommand(['-C', path, 'fetch', 'origin']);
-  if (fetchResult.exitCode !== 0) {
-    return { success: false, conflicts: ['Failed to fetch from origin'] };
+  if (source === 'origin' || (baseBranch && !source)) {
+    const fetchResult = await gitCommand(['-C', path, 'fetch', 'origin']);
+    if (fetchResult.exitCode !== 0) {
+      return { success: false, conflicts: ['Failed to fetch from origin'] };
+    }
   }
 
   const syncResult = await gitCommand(['-C', path, strategy, targetBranch]);
@@ -285,7 +278,7 @@ export class GitWorktreeProvider implements WorktreeProvider {
     return listWorktrees();
   }
 
-  async sync(path: string, strategy: 'rebase' | 'merge', baseBranch?: string): Promise<SyncResult> {
-    return syncWorktree(path, strategy, baseBranch);
+  async sync(path: string, strategy: 'rebase' | 'merge', baseBranch?: string, source?: 'local' | 'origin'): Promise<SyncResult> {
+    return syncWorktree(path, strategy, baseBranch, source);
   }
 }

src/tools/sync.ts

@@ -10,6 +10,10 @@ export const mc_sync: ToolDefinition = tool({
       .enum(['rebase', 'merge'])
       .optional()
       .describe('Sync strategy (default: rebase)'),
+    source: tool.schema
+      .enum(['local', 'origin'])
+      .optional()
+      .describe('Sync source: local base branch (default) or origin'),
   },
   async execute(args) {
     // 1. Find job by name
@@ -22,9 +26,12 @@ export const mc_sync: ToolDefinition = tool({
     const syncStrategy = args.strategy || 'rebase';
 
     // 3. Sync the worktree
-    const result = job.baseBranch
-      ? await syncWorktree(job.worktreePath, syncStrategy, job.baseBranch)
-      : await syncWorktree(job.worktreePath, syncStrategy);
+    const result = await syncWorktree(
+      job.worktreePath,
+      syncStrategy,
+      job.baseBranch,
+      args.source,
+    );
 
     // 4. Format output
     if (result.success) {

tests/tools/sync.test.ts

@@ -85,23 +85,29 @@ describe('mc_sync', () => {
 
       await mc_sync.execute({ name: 'test-job' }, mockContext);
 
-      expect(mockSyncWorktree).toHaveBeenCalledWith('/tmp/mc-worktrees/test-job', 'rebase');
+      expect(mockSyncWorktree).toHaveBeenCalledWith(
+        '/tmp/mc-worktrees/test-job', 'rebase', undefined, undefined,
+      );
     });
 
     it('should use specified rebase strategy', async () => {
       mockSyncWorktree.mockResolvedValue({ success: true });
 
       await mc_sync.execute({ name: 'test-job', strategy: 'rebase' }, mockContext);
 
-      expect(mockSyncWorktree).toHaveBeenCalledWith('/tmp/mc-worktrees/test-job', 'rebase');
+      expect(mockSyncWorktree).toHaveBeenCalledWith(
+        '/tmp/mc-worktrees/test-job', 'rebase', undefined, undefined,
+      );
     });
 
     it('should use specified merge strategy', async () => {
       mockSyncWorktree.mockResolvedValue({ success: true });
 
       await mc_sync.execute({ name: 'test-job', strategy: 'merge' }, mockContext);
 
-      expect(mockSyncWorktree).toHaveBeenCalledWith('/tmp/mc-worktrees/test-job', 'merge');
+      expect(mockSyncWorktree).toHaveBeenCalledWith(
+        '/tmp/mc-worktrees/test-job', 'merge', undefined, undefined,
+      );
     });
   });
 
@@ -187,6 +193,53 @@ describe('mc_sync', () => {
     });
   });
 
+  describe('source parameter', () => {
+    beforeEach(() => {
+      mockGetJobByName.mockResolvedValue(createMockJob());
+      mockSyncWorktree.mockResolvedValue({ success: true });
+    });
+
+    it('should have optional arg: source', () => {
+      expect(mc_sync.args.source).toBeDefined();
+    });
+
+    it('should pass source=local to syncWorktree', async () => {
+      await mc_sync.execute({ name: 'test-job', source: 'local' }, mockContext);
+
+      expect(mockSyncWorktree).toHaveBeenCalledWith(
+        '/tmp/mc-worktrees/test-job', 'rebase', undefined, 'local',
+      );
+    });
+
+    it('should pass source=origin to syncWorktree', async () => {
+      await mc_sync.execute({ name: 'test-job', source: 'origin' }, mockContext);
+
+      expect(mockSyncWorktree).toHaveBeenCalledWith(
+        '/tmp/mc-worktrees/test-job', 'rebase', undefined, 'origin',
+      );
+    });
+
+    it('should pass baseBranch from job along with source', async () => {
+      mockGetJobByName.mockResolvedValue(createMockJob({ baseBranch: 'develop' }));
+
+      await mc_sync.execute({ name: 'test-job', source: 'local' }, mockContext);
+
+      expect(mockSyncWorktree).toHaveBeenCalledWith(
+        '/tmp/mc-worktrees/test-job', 'rebase', 'develop', 'local',
+      );
+    });
+
+    it('should pass baseBranch without source', async () => {
+      mockGetJobByName.mockResolvedValue(createMockJob({ baseBranch: 'develop' }));
+
+      await mc_sync.execute({ name: 'test-job' }, mockContext);
+
+      expect(mockSyncWorktree).toHaveBeenCalledWith(
+        '/tmp/mc-worktrees/test-job', 'rebase', 'develop', undefined,
+      );
+    });
+  });
+
   describe('different job names', () => {
     it('should work with different job names', async () => {
       mockGetJobByName.mockResolvedValue(createMockJob({ name: 'feature-branch' }));
@@ -217,7 +270,7 @@ describe('mc_sync', () => {
 
       await mc_sync.execute({ name: 'test-job' }, mockContext);
 
-      expect(mockSyncWorktree).toHaveBeenCalledWith(worktreePath, 'rebase');
+      expect(mockSyncWorktree).toHaveBeenCalledWith(worktreePath, 'rebase', undefined, undefined);
     });
   });
 });