fix(sync): use pre-pull commit as merge base after git pull

After git pull, the sync engine was using HEAD (post-pull) as the 3-way
merge base, making it appear that only the target changed. This caused
local files to always overwrite remote changes. Now captures HEAD before
pulling and uses it as the correct base for post-pull sync.

v0.2.2

Author: dinhanhthi

docs/changelog.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## v0.2.2
+
+- Fix post-pull sync using wrong base: after git pull, the sync engine now uses the pre-pull commit as the merge base, correctly detecting remote vs local changes instead of always keeping local
+
 ## v0.2.1
 
 - Handle store config conflicts during git pull

docs/documentation.md

@@ -245,7 +245,11 @@ Untrack patterns are persisted in the local database and in `sync-settings.json`
 
 If your data directory is connected to a remote git repository, use the **Push** button in the footer to push your store to the remote. This backs up your AI configs and makes them available on other machines.
 
-Use the **Pull** button to pull the latest changes from the remote. This will merge the remote changes into your local store.
+Use the **Pull** button to pull the latest changes from the remote. After pulling, the sync engine automatically runs a full sync pass using the **pre-pull state** as the merge base. This correctly detects which files were changed by the remote vs which were changed locally:
+
+- **Only remote changed** — updates are applied to local targets automatically
+- **Only local changed** — local changes are preserved and pushed back to the store
+- **Both changed** — non-overlapping edits are auto-merged; overlapping edits create a conflict for manual resolution
 
 ## Setting Up on a New Machine
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "ai-sync",
   "author": "Anh-Thi Dinh",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "repository": "https://github.com/anhthiding/ai-sync",
   "private": true,
   "license": "MIT",
@@ -39,5 +39,5 @@
       "esbuild"
     ]
   },
-  "packageManager": "pnpm@10.29.3+sha512.498e1fb4cca5aa06c1dcf2611e6fafc50972ffe7189998c409e90de74566444298ffe43e6cd2acdc775ba1aa7cc5e092a8b7054c811ba8c5770f84693d33d2dc"
+  "packageManager": "pnpm@10.30.2+sha512.36cdc707e7b7940a988c9c1ecf88d084f8514b5c3f085f53a2e244c2921d3b2545bc20dd4ebe1fc245feec463bb298aecea7a63ed1f7680b877dc6379d8d0cb4"
 }

packages/server/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ai-sync/server",
   "author": "Anh-Thi Dinh",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "repository": "https://github.com/anhthiding/ai-sync",
   "private": true,
   "license": "MIT",

packages/server/src/routes/sync.ts

@@ -29,6 +29,15 @@ export function registerSyncRoutes(app: FastifyInstance, state: AppState): void
 
     try {
       const result = await pullStoreChanges();
+
+      // After a successful pull, trigger sync using the pre-pull base
+      // so the engine correctly detects remote changes vs local changes
+      if (result.pulled && result.prePullCommitHash && state.syncEngine) {
+        state.syncEngine.syncAfterPull(result.prePullCommitHash).catch((err) => {
+          console.error('Post-pull sync failed:', err);
+        });
+      }
+
       return result;
     } catch (err) {
       const message = err instanceof Error ? err.message : 'Pull failed';

packages/server/src/services/__tests__/sync-engine.test.ts

@@ -14,11 +14,13 @@ import { contentChecksum } from '../checksum.js';
 // Mock store-git module: control what "base" version git returns
 // and prevent actual git commit/init operations
 let mockBaseContent: string | null = null;
+let mockBaseContentAt: string | null = null;
 
 vi.mock('../store-git.js', () => ({
   queueStoreCommit: vi.fn(),
   ensureStoreCommitted: vi.fn().mockResolvedValue(undefined),
   getCommittedContent: vi.fn(async () => mockBaseContent),
+  getCommittedContentAt: vi.fn(async () => mockBaseContentAt),
   gitMergeFile: vi.fn(async (base: string, store: string, target: string) => {
     // Use real git merge-file via child_process
     const { execFile } = await import('node:child_process');
@@ -176,6 +178,10 @@ function setBase(content: string | null) {
   mockBaseContent = content;
 }
 
+function setBaseAt(content: string | null) {
+  mockBaseContentAt = content;
+}
+
 // ── Setup / Teardown ─────────────────────────────────────────────────────────
 
 beforeEach(async () => {
@@ -209,6 +215,7 @@ beforeEach(async () => {
 
   // Reset mock base
   mockBaseContent = null;
+  mockBaseContentAt = null;
 
   // Create engine and capture broadcasts
   engine = new SyncEngine(db);
@@ -1025,3 +1032,211 @@ describe('SyncEngine.syncFile — Git-based 3-way merge', () => {
     expect(getConflicts()).toHaveLength(0);
   });
 });
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  Post-pull sync tests — verifies correct base resolution after git pull
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('SyncEngine.syncAfterPull — post-pull base resolution', () => {
+  // ╔═══════════════════════════════════════════════════════════════════════╗
+  // ║  Scenario: Both sides changed after pull → conflict                 ║
+  // ╚═══════════════════════════════════════════════════════════════════════╝
+  it('creates conflict when both sides changed from pre-pull base', async () => {
+    // Machine A pushed "A2", Machine B has "B1"
+    // Pre-pull base was "A1" (original content both machines had)
+    // After pull: store=A2 (from remote), target=B1 (local edit)
+    setBaseAt('A1'); // getCommittedContentAt returns pre-pull base
+
+    await writeStoreFile('A2'); // pulled from remote
+    await writeTargetFile('B1'); // local edit
+
+    const checksum = contentChecksum('A1');
+    const tf = makeTrackedFile({
+      storeChecksum: checksum,
+      targetChecksum: checksum,
+      lastSyncedAt: new Date().toISOString(),
+    });
+    db.prepare(
+      "INSERT INTO tracked_files (id, repo_id, relative_path, store_checksum, target_checksum, sync_status, last_synced_at) VALUES (?, ?, ?, ?, ?, 'synced', ?)",
+    ).run(tf.id, tf.repoId, tf.relativePath, tf.storeChecksum, tf.targetChecksum, tf.lastSyncedAt);
+
+    await engine.syncAfterPull('fake-pre-pull-hash');
+
+    // Both changed from base "A1" → should create conflict
+    const conflicts = getConflicts();
+    expect(conflicts).toHaveLength(1);
+    expect(conflicts[0].store_content).toBe('A2');
+    expect(conflicts[0].target_content).toBe('B1');
+
+    const updated = getTrackedFile()!;
+    expect(updated.syncStatus).toBe('conflict');
+  });
+
+  // ╔═══════════════════════════════════════════════════════════════════════╗
+  // ║  Scenario: Only store changed after pull → sync to target           ║
+  // ╚═══════════════════════════════════════════════════════════════════════╝
+  it('syncs store→target when only store changed from pre-pull base', async () => {
+    // Store pulled "A2", target still has "A1" (unchanged)
+    setBaseAt('A1');
+
+    await writeStoreFile('A2');
+    await writeTargetFile('A1');
+
+    const checksum = contentChecksum('A1');
+    const tf = makeTrackedFile({
+      storeChecksum: checksum,
+      targetChecksum: checksum,
+      lastSyncedAt: new Date().toISOString(),
+    });
+    db.prepare(
+      "INSERT INTO tracked_files (id, repo_id, relative_path, store_checksum, target_checksum, sync_status, last_synced_at) VALUES (?, ?, ?, ?, ?, 'synced', ?)",
+    ).run(tf.id, tf.repoId, tf.relativePath, tf.storeChecksum, tf.targetChecksum, tf.lastSyncedAt);
+
+    await engine.syncAfterPull('fake-pre-pull-hash');
+
+    // Only store changed → target should get the update
+    const targetContent = await readTargetFile();
+    expect(targetContent).toBe('A2');
+    expect(getConflicts()).toHaveLength(0);
+
+    const updated = getTrackedFile()!;
+    expect(updated.syncStatus).toBe('synced');
+  });
+
+  // ╔═══════════════════════════════════════════════════════════════════════╗
+  // ║  Scenario: Pulled content same as target → fast path                ║
+  // ╚═══════════════════════════════════════════════════════════════════════╝
+  it('takes fast path when pulled content matches target content', async () => {
+    // Both sides end up with same content after pull
+    await writeStoreFile('Same');
+    await writeTargetFile('Same');
+
+    const oldChecksum = contentChecksum('Old');
+    const tf = makeTrackedFile({
+      storeChecksum: oldChecksum,
+      targetChecksum: oldChecksum,
+      lastSyncedAt: new Date().toISOString(),
+    });
+    db.prepare(
+      "INSERT INTO tracked_files (id, repo_id, relative_path, store_checksum, target_checksum, sync_status, last_synced_at) VALUES (?, ?, ?, ?, ?, 'synced', ?)",
+    ).run(tf.id, tf.repoId, tf.relativePath, tf.storeChecksum, tf.targetChecksum, tf.lastSyncedAt);
+
+    await engine.syncAfterPull('fake-pre-pull-hash');
+
+    const updated = getTrackedFile()!;
+    expect(updated.syncStatus).toBe('synced');
+    expect(getConflicts()).toHaveLength(0);
+  });
+
+  // ╔═══════════════════════════════════════════════════════════════════════╗
+  // ║  Scenario: Non-overlapping changes → auto-merge                     ║
+  // ╚═══════════════════════════════════════════════════════════════════════╝
+  it('auto-merges non-overlapping changes after pull', async () => {
+    const originalContent = 'Line 1\nLine 2\nLine 3\n';
+    setBaseAt(originalContent);
+
+    // Store (pulled) adds line at top, target adds line at bottom
+    await writeStoreFile('Line 0\nLine 1\nLine 2\nLine 3\n');
+    await writeTargetFile('Line 1\nLine 2\nLine 3\nLine 4\n');
+
+    const checksum = contentChecksum(originalContent);
+    const tf = makeTrackedFile({
+      storeChecksum: checksum,
+      targetChecksum: checksum,
+      lastSyncedAt: new Date().toISOString(),
+    });
+    db.prepare(
+      "INSERT INTO tracked_files (id, repo_id, relative_path, store_checksum, target_checksum, sync_status, last_synced_at) VALUES (?, ?, ?, ?, ?, 'synced', ?)",
+    ).run(tf.id, tf.repoId, tf.relativePath, tf.storeChecksum, tf.targetChecksum, tf.lastSyncedAt);
+
+    await engine.syncAfterPull('fake-pre-pull-hash');
+
+    const storeContent = await readStoreFile();
+    const targetContent = await readTargetFile();
+    expect(storeContent).toBe('Line 0\nLine 1\nLine 2\nLine 3\nLine 4\n');
+    expect(targetContent).toBe(storeContent);
+    expect(getConflicts()).toHaveLength(0);
+
+    const updated = getTrackedFile()!;
+    expect(updated.syncStatus).toBe('synced');
+  });
+
+  // ╔═══════════════════════════════════════════════════════════════════════╗
+  // ║  Scenario: Override cleared after sync completes                    ║
+  // ╚═══════════════════════════════════════════════════════════════════════╝
+  it('clears baseCommitOverride after syncAfterPull, normal sync uses HEAD', async () => {
+    // First: run syncAfterPull with a simple fast-path case
+    await writeStoreFile('Same');
+    await writeTargetFile('Same');
+
+    const checksum = contentChecksum('Old');
+    const tf = makeTrackedFile({
+      storeChecksum: checksum,
+      targetChecksum: checksum,
+      lastSyncedAt: new Date().toISOString(),
+    });
+    db.prepare(
+      "INSERT INTO tracked_files (id, repo_id, relative_path, store_checksum, target_checksum, sync_status, last_synced_at) VALUES (?, ?, ?, ?, ?, 'synced', ?)",
+    ).run(tf.id, tf.repoId, tf.relativePath, tf.storeChecksum, tf.targetChecksum, tf.lastSyncedAt);
+
+    await engine.syncAfterPull('fake-hash');
+
+    // Clear mocks to track new calls
+    const storeGitMod = await import('../store-git.js');
+    vi.mocked(storeGitMod.getCommittedContent).mockClear();
+    vi.mocked(storeGitMod.getCommittedContentAt).mockClear();
+
+    // Now run normal syncFile — should use getCommittedContent (HEAD), not getCommittedContentAt
+    setBase('Normal base');
+    await writeStoreFile('Store v2');
+    await writeTargetFile('Normal base');
+
+    const updatedTf = getTrackedFile()!;
+    await engine.syncFile(updatedTf, makeRepo());
+
+    expect(storeGitMod.getCommittedContent).toHaveBeenCalled();
+    expect(storeGitMod.getCommittedContentAt).not.toHaveBeenCalled();
+  });
+
+  // ╔═══════════════════════════════════════════════════════════════════════╗
+  // ║  Scenario: Override cleared even on error                           ║
+  // ╚═══════════════════════════════════════════════════════════════════════╝
+  it('clears baseCommitOverride even when sync throws', async () => {
+    // Make syncAllRepos fail by closing the DB temporarily is hard,
+    // so we verify override is null after syncAfterPull by checking
+    // a subsequent normal sync doesn't use getCommittedContentAt
+    const storeGitMod = await import('../store-git.js');
+
+    // Run syncAfterPull (will succeed on empty repos list which is fine)
+    // Delete the repo from DB so syncAllRepos finds nothing
+    db.prepare('DELETE FROM repos').run();
+    await engine.syncAfterPull('some-hash');
+
+    // Re-insert repo
+    db.prepare(
+      "INSERT INTO repos (id, name, local_path, store_path, status) VALUES (?, ?, ?, ?, 'active')",
+    ).run(REPO_ID, REPO_NAME, targetRepoPath, STORE_PATH);
+
+    vi.mocked(storeGitMod.getCommittedContent).mockClear();
+    vi.mocked(storeGitMod.getCommittedContentAt).mockClear();
+
+    // Normal sync should use HEAD
+    setBase('Base');
+    await writeStoreFile('Changed');
+    await writeTargetFile('Base');
+
+    const tf = makeTrackedFile({
+      storeChecksum: contentChecksum('Base'),
+      targetChecksum: contentChecksum('Base'),
+      lastSyncedAt: new Date().toISOString(),
+    });
+    db.prepare(
+      "INSERT INTO tracked_files (id, repo_id, relative_path, store_checksum, target_checksum, sync_status, last_synced_at) VALUES (?, ?, ?, ?, ?, 'synced', ?)",
+    ).run(tf.id, tf.repoId, tf.relativePath, tf.storeChecksum, tf.targetChecksum, tf.lastSyncedAt);
+
+    await engine.syncFile(tf, makeRepo());
+
+    expect(storeGitMod.getCommittedContent).toHaveBeenCalled();
+    expect(storeGitMod.getCommittedContentAt).not.toHaveBeenCalled();
+  });
+});

packages/server/src/services/store-git.ts

@@ -207,6 +207,7 @@ export interface PullResult {
   pulled: boolean;
   message: string;
   storeConflicts?: StoreConfigConflict[];
+  prePullCommitHash?: string;
 }
 
 /** Parse conflict markers from a conflicted file, returning ours and theirs content. */
@@ -252,6 +253,10 @@ export async function pullStoreChanges(): Promise<PullResult> {
   }
 
   const branch = await git.branchLocal();
+
+  // Capture HEAD before pulling — this is the correct base for 3-way merge
+  const prePullHash = await getHeadCommitHash();
+
   try {
     await git.pull(remote, branch.current);
   } catch (err) {
@@ -283,14 +288,19 @@ export async function pullStoreChanges(): Promise<PullResult> {
         pulled: true,
         message: `Pulled from ${remote}/${branch.current} with config conflicts`,
         storeConflicts,
+        prePullCommitHash: prePullHash ?? undefined,
       };
     }
 
     // Re-throw if no config conflicts (other errors like network issues)
     throw err;
   }
 
-  return { pulled: true, message: `Pulled from ${remote}/${branch.current}` };
+  return {
+    pulled: true,
+    message: `Pulled from ${remote}/${branch.current}`,
+    prePullCommitHash: prePullHash ?? undefined,
+  };
 }
 
 /**
@@ -372,6 +382,40 @@ export async function getCommittedContent(relativePath: string): Promise<string
   }
 }
 
+/**
+ * Get the committed content of a file at a specific commit ref.
+ * Used to retrieve the pre-pull base for 3-way merge after git pull.
+ * Returns null if the file doesn't exist at that commit.
+ */
+export async function getCommittedContentAt(
+  relativePath: string,
+  commitRef: string,
+): Promise<string | null> {
+  if (!git) {
+    git = createGit(config.storePath);
+  }
+  try {
+    return await git.raw(['show', `${commitRef}:${relativePath}`]);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the current HEAD commit hash of the store repo.
+ */
+export async function getHeadCommitHash(): Promise<string | null> {
+  if (!git) {
+    git = createGit(config.storePath);
+  }
+  try {
+    const hash = await git.raw(['rev-parse', 'HEAD']);
+    return hash.trim();
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Ensure all store changes are committed before using git for comparison.
  * This prevents stale HEAD when files were written but not yet committed.