Merge remote-tracking branch 'origin/main'

dinhanhthi · dinhanhthi · commit 433956375e77 · 2026-02-24T17:54:06.000+01:00
diff --git a/docs/changelog.md b/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
diff --git a/docs/documentation.md b/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
 
diff --git a/package.json b/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",
diff --git a/packages/landing/src/components/sections/features.tsx b/packages/landing/src/components/sections/features.tsx
@@ -94,7 +94,7 @@ const features = [
 
 export function FeaturesSection() {
   return (
-    <section className="py-20">
+    <section className="py-12 sm:py-16 md:py-20">
       <h2 className="text-3xl font-bold tracking-tight text-center mb-12">Main Features</h2>
       <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4">
         {features.map((feature) => (
diff --git a/packages/landing/src/components/sections/hero.tsx b/packages/landing/src/components/sections/hero.tsx
@@ -1,6 +1,6 @@
 export function HeroSection() {
   return (
-    <section className="py-24 text-center animate-fade-up delay-100">
+    <section className="py-12 sm:py-16 md:py-20 text-center animate-fade-up delay-100">
       <img src="/logo.svg" alt="AI Sync logo" className="mx-auto mb-6 h-20 w-20" />
       <h1 className="text-4xl sm:text-5xl lg:text-6xl font-bold tracking-tight leading-tight mb-6">
         Sync Your AI Configs
diff --git a/packages/landing/src/components/sections/how-it-works.tsx b/packages/landing/src/components/sections/how-it-works.tsx
@@ -1,6 +1,6 @@
 export function HowItWorksSection() {
   return (
-    <section id="how" className="py-20">
+    <section id="how" className="py-12 sm:py-16 md:py-20">
       <h2 className="text-3xl font-bold tracking-tight text-center mb-4">How It Works</h2>
       <p className="text-center text-muted-foreground mb-12">
         A background service watches your files and syncs them to a central git store.
diff --git a/packages/landing/src/components/sections/installation.tsx b/packages/landing/src/components/sections/installation.tsx
@@ -25,7 +25,7 @@ function CodeBlock({ children }: { children: string }) {
 
 export function InstallationSection() {
   return (
-    <section id="install" className="py-20 scroll-mt-10">
+    <section id="install" className="py-12 sm:py-16 md:py-20 scroll-mt-10">
       <h2 className="text-3xl font-bold tracking-tight text-center mb-12">
         Installation &amp; Usage
       </h2>
diff --git a/packages/landing/src/components/sections/multi-machine.tsx b/packages/landing/src/components/sections/multi-machine.tsx
@@ -1,6 +1,6 @@
 export function MultiMachineSection() {
   return (
-    <section className="py-20">
+    <section className="py-12 sm:py-16 md:py-20">
       <h2 className="text-3xl font-bold tracking-tight text-center mb-4">Work Across Machines</h2>
       <p className="text-center text-muted-foreground mb-12 max-w-2xl mx-auto">
         Your store is just a Git repo. Push it to GitHub (private) and pull it on another machine.
diff --git a/packages/landing/src/components/sections/why.tsx b/packages/landing/src/components/sections/why.tsx
@@ -45,7 +45,7 @@ export function WhySection() {
   ];
 
   return (
-    <section id="why" className="py-20 animate-fade-up delay-200">
+    <section id="why" className="py-12 sm:py-16 md:py-20 animate-fade-up delay-200">
       <h2 className="text-3xl font-bold tracking-tight text-center mb-12">Why AI Sync?</h2>
       <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
         {cards.map((card) => (
diff --git a/packages/server/package.json b/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",
diff --git a/packages/server/src/routes/sync.ts b/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';
diff --git a/packages/server/src/services/__tests__/sync-engine.test.ts b/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();
+  });
+});
diff --git a/packages/server/src/services/store-git.ts b/packages/server/src/services/store-git.ts
diff --git a/packages/server/src/services/sync-engine.ts b/packages/server/src/services/sync-engine.ts
diff --git a/packages/ui/package.json b/packages/ui/package.json
diff --git a/packages/ui/src/components/layout.tsx b/packages/ui/src/components/layout.tsx
diff --git a/packages/ui/src/lib/api.ts b/packages/ui/src/lib/api.ts

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "ai-sync",`
`3`	`3`	`"author": "Anh-Thi Dinh",`
`4`		`- "version": "0.2.1",`
	`4`	`+ "version": "0.2.2",`
`5`	`5`	`"repository": "https://github.com/anhthiding/ai-sync",`
`6`	`6`	`"private": true,`
`7`	`7`	`"license": "MIT",`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@ai-sync/server",`
`3`	`3`	`"author": "Anh-Thi Dinh",`
`4`		`- "version": "0.2.1",`
	`4`	`+ "version": "0.2.2",`
`5`	`5`	`"repository": "https://github.com/anhthiding/ai-sync",`
`6`	`6`	`"private": true,`
`7`	`7`	`"license": "MIT",`