runwork 0.2.4 → 0.3.0

package/dist/git/__tests__/sync.test.js

@@ -0,0 +1,405 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { execFileSync } from 'child_process';
+import { mkdtempSync, writeFileSync, readFileSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { syncWithRemote, hasCommits, hasTrackedChanges } from '../sync.js';
+const tempDirs = [];
+function makeTempDir(prefix) {
+    const dir = mkdtempSync(join(tmpdir(), `runwork-sync-test-${prefix}-`));
+    tempDirs.push(dir);
+    return dir;
+}
+function createTestRepo() {
+    const remote = makeTempDir('remote');
+    execFileSync('git', ['init', '--bare', remote]);
+    const local = makeTempDir('local');
+    execFileSync('git', ['init', local]);
+    execFileSync('git', ['remote', 'add', 'runwork', remote], { cwd: local });
+    execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: local });
+    execFileSync('git', ['config', 'user.name', 'Test'], { cwd: local });
+    return { local, remote };
+}
+/** Create a second clone of the same bare remote (for simulating remote-side commits). */
+function cloneAsSecondary(remote) {
+    const secondary = makeTempDir('secondary');
+    execFileSync('git', ['clone', remote, secondary]);
+    execFileSync('git', ['config', 'user.email', 'other@test.com'], { cwd: secondary });
+    execFileSync('git', ['config', 'user.name', 'Other'], { cwd: secondary });
+    return secondary;
+}
+function commitFile(repoDir, filename, content, message) {
+    writeFileSync(join(repoDir, filename), content);
+    execFileSync('git', ['add', filename], { cwd: repoDir });
+    execFileSync('git', ['commit', '-m', message], { cwd: repoDir });
+    return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: repoDir, encoding: 'utf-8' }).trim();
+}
+function getLog(repoDir) {
+    return execFileSync('git', ['log', '--oneline', '--all'], { cwd: repoDir, encoding: 'utf-8' })
+        .trim()
+        .split('\n')
+        .filter(Boolean);
+}
+function getHeadHash(repoDir) {
+    return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: repoDir, encoding: 'utf-8' }).trim();
+}
+afterEach(() => {
+    for (const dir of tempDirs) {
+        try {
+            rmSync(dir, { recursive: true, force: true });
+        }
+        catch { /* best effort */ }
+    }
+    tempDirs.length = 0;
+});
+describe('hasCommits()', () => {
+    it('returns false for repo with no commits', () => {
+        const dir = makeTempDir('empty');
+        execFileSync('git', ['init', dir]);
+        expect(hasCommits(dir)).toBe(false);
+    });
+    it('returns true for repo with commits', () => {
+        const { local } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        expect(hasCommits(local)).toBe(true);
+    });
+});
+describe('hasTrackedChanges()', () => {
+    it('returns false for clean working tree', () => {
+        const { local } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        expect(hasTrackedChanges(local)).toBe(false);
+    });
+    it('returns true for modified tracked file', () => {
+        const { local } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        writeFileSync(join(local, 'a.txt'), 'changed');
+        expect(hasTrackedChanges(local)).toBe(true);
+    });
+    it('returns false when only untracked files exist', () => {
+        const { local } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        writeFileSync(join(local, 'untracked.txt'), 'new');
+        expect(hasTrackedChanges(local)).toBe(false);
+    });
+});
+describe('syncWithRemote()', () => {
+    it('returns skipped when there are no local commits', () => {
+        const { local } = createTestRepo();
+        const result = syncWithRemote(local);
+        expect(result).toEqual({ status: 'skipped', pushed: false });
+    });
+    it('syncs when local and remote are already in sync', () => {
+        const { local, remote } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
+        const result = syncWithRemote(local);
+        expect(result.status).toBe('synced');
+        expect(result.pushed).toBe(true);
+    });
+    it('pushes local commits when remote has no new changes', () => {
+        const { local, remote } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
+        // Add a new local commit
+        commitFile(local, 'b.txt', 'world', 'second');
+        const localHead = getHeadHash(local);
+        const result = syncWithRemote(local);
+        expect(result.status).toBe('synced');
+        expect(result.pushed).toBe(true);
+        // Verify remote has the new commit
+        const remoteHead = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: remote, encoding: 'utf-8' }).trim();
+        expect(remoteHead).toBe(localHead);
+    });
+    it('rebases local on remote when remote has new commits', () => {
+        const { local, remote } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
+        // Push a commit from another clone to simulate remote changes
+        const secondary = cloneAsSecondary(remote);
+        commitFile(secondary, 'remote-file.txt', 'from-remote', 'remote commit');
+        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
+        const result = syncWithRemote(local);
+        expect(result.status).toBe('synced');
+        // Local should now have the remote file
+        expect(existsSync(join(local, 'remote-file.txt'))).toBe(true);
+        expect(readFileSync(join(local, 'remote-file.txt'), 'utf-8')).toBe('from-remote');
+    });
+    it('rebases when both sides have non-conflicting commits', () => {
+        const { local, remote } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
+        // Remote adds a file
+        const secondary = cloneAsSecondary(remote);
+        commitFile(secondary, 'remote-file.txt', 'remote-content', 'remote commit');
+        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
+        // Local adds a different file
+        commitFile(local, 'local-file.txt', 'local-content', 'local commit');
+        const result = syncWithRemote(local);
+        expect(result.status).toBe('synced');
+        expect(result.pushed).toBe(true);
+        // Both files should be present
+        expect(readFileSync(join(local, 'remote-file.txt'), 'utf-8')).toBe('remote-content');
+        expect(readFileSync(join(local, 'local-file.txt'), 'utf-8')).toBe('local-content');
+        // Verify remote also has both
+        const secondaryCheck = cloneAsSecondary(remote);
+        expect(existsSync(join(secondaryCheck, 'remote-file.txt'))).toBe(true);
+        expect(existsSync(join(secondaryCheck, 'local-file.txt'))).toBe(true);
+    });
+    it('handles unrelated histories with non-overlapping files via rebase', () => {
+        const { local, remote } = createTestRepo();
+        // Local has its own history
+        commitFile(local, 'local-file.txt', 'local', 'local init');
+        // Create a completely separate history and force-push it to remote
+        const other = makeTempDir('other');
+        execFileSync('git', ['init', other]);
+        execFileSync('git', ['config', 'user.email', 'other@test.com'], { cwd: other });
+        execFileSync('git', ['config', 'user.name', 'Other'], { cwd: other });
+        commitFile(other, 'remote-only.txt', 'remote', 'remote init');
+        execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: other });
+        execFileSync('git', ['push', 'origin', 'main'], { cwd: other, stdio: 'pipe' });
+        const result = syncWithRemote(local);
+        // Modern git can rebase non-conflicting unrelated histories
+        expect(['synced', 'merged']).toContain(result.status);
+        // Both files should be present regardless of strategy used
+        expect(existsSync(join(local, 'local-file.txt'))).toBe(true);
+        expect(existsSync(join(local, 'remote-only.txt'))).toBe(true);
+    });
+    it('auto-resolves conflicting unrelated histories by accepting remote', () => {
+        const { local, remote } = createTestRepo();
+        // Local modifies a file
+        commitFile(local, 'shared.txt', 'local-line-1\nlocal-line-2\n', 'local init');
+        // Remote has completely different history touching the same file
+        const other = makeTempDir('other');
+        execFileSync('git', ['init', other]);
+        execFileSync('git', ['config', 'user.email', 'other@test.com'], { cwd: other });
+        execFileSync('git', ['config', 'user.name', 'Other'], { cwd: other });
+        commitFile(other, 'shared.txt', 'remote-line-1\nremote-line-2\n', 'remote init');
+        execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: other });
+        execFileSync('git', ['push', 'origin', 'main'], { cwd: other, stdio: 'pipe' });
+        const result = syncWithRemote(local);
+        // Conflicts auto-resolved with -X theirs (remote wins for first sync)
+        expect(result.status).toBe('merged');
+        // Remote version should win
+        expect(readFileSync(join(local, 'shared.txt'), 'utf-8')).toBe('remote-line-1\nremote-line-2\n');
+    });
+    it('stashes and restores dirty working tree during sync', () => {
+        const { local, remote } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
+        // Remote adds a commit
+        const secondary = cloneAsSecondary(remote);
+        commitFile(secondary, 'remote-file.txt', 'remote', 'remote commit');
+        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
+        // Make local dirty (modify a tracked file without committing)
+        writeFileSync(join(local, 'a.txt'), 'dirty-change');
+        const result = syncWithRemote(local);
+        expect(result.status).toBe('synced');
+        // Dirty change should be preserved
+        expect(readFileSync(join(local, 'a.txt'), 'utf-8')).toBe('dirty-change');
+        // Remote file should also be present
+        expect(existsSync(join(local, 'remote-file.txt'))).toBe(true);
+    });
+    it('reports stash conflict when stash pop fails', () => {
+        const { local, remote } = createTestRepo();
+        commitFile(local, 'shared.txt', 'original', 'init');
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
+        // Remote modifies the same file
+        const secondary = cloneAsSecondary(remote);
+        writeFileSync(join(secondary, 'shared.txt'), 'remote-version');
+        execFileSync('git', ['add', 'shared.txt'], { cwd: secondary });
+        execFileSync('git', ['commit', '-m', 'remote change to shared'], { cwd: secondary });
+        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
+        // Local has uncommitted changes to the same file
+        writeFileSync(join(local, 'shared.txt'), 'local-dirty-version');
+        const result = syncWithRemote(local);
+        expect(result.error).toBe('stash-conflict');
+        expect(result.pushed).toBe(false);
+    });
+    it('handles fetch failure gracefully (unreachable remote)', () => {
+        const { local } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        // Point remote to a non-existent path
+        const badPath = join(tmpdir(), 'nonexistent-repo-' + Date.now());
+        execFileSync('git', ['remote', 'set-url', 'runwork', badPath], { cwd: local });
+        const result = syncWithRemote(local);
+        expect(result.status).toBe('sync-failed');
+        expect(result.pushed).toBe(false);
+        // Local repo should be untouched
+        expect(readFileSync(join(local, 'a.txt'), 'utf-8')).toBe('hello');
+    });
+    it('removes conflicting untracked files before rebase', () => {
+        const { local, remote } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
+        // Remote adds a new file via secondary clone
+        const secondary = cloneAsSecondary(remote);
+        commitFile(secondary, 'skeleton.txt', 'from-remote', 'add skeleton');
+        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
+        // Local has the same file as untracked (simulating template download)
+        writeFileSync(join(local, 'skeleton.txt'), 'local-untracked-version');
+        const result = syncWithRemote(local);
+        expect(result.status).toBe('synced');
+        // The file should now contain the remote version (committed)
+        expect(readFileSync(join(local, 'skeleton.txt'), 'utf-8')).toBe('from-remote');
+    });
+    it('preserves local state when fetch fails with dirty tree', () => {
+        const { local } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        // Make working tree dirty
+        writeFileSync(join(local, 'a.txt'), 'dirty');
+        // Point remote to bad path
+        const badPath = join(tmpdir(), 'nonexistent-repo-' + Date.now());
+        execFileSync('git', ['remote', 'set-url', 'runwork', badPath], { cwd: local });
+        const result = syncWithRemote(local);
+        expect(result.status).toBe('sync-failed');
+        // Dirty changes should be restored from stash
+        expect(readFileSync(join(local, 'a.txt'), 'utf-8')).toBe('dirty');
+    });
+});
+// ============================================================
+// EDGE CASE TESTS - probing for real bugs
+// ============================================================
+describe('hasTrackedChanges() edge cases', () => {
+    it('returns true for staged deletions (git rm)', () => {
+        const { local } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        // Stage a deletion
+        execFileSync('git', ['rm', 'a.txt'], { cwd: local, stdio: 'pipe' });
+        // git status --porcelain shows "D  a.txt" which does not start with "??"
+        expect(hasTrackedChanges(local)).toBe(true);
+    });
+    it('returns true for staged new file (git add of new file)', () => {
+        const { local } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        // Create and stage a new file (status: "A  new.txt")
+        writeFileSync(join(local, 'new.txt'), 'new content');
+        execFileSync('git', ['add', 'new.txt'], { cwd: local, stdio: 'pipe' });
+        expect(hasTrackedChanges(local)).toBe(true);
+    });
+});
+describe('syncWithRemote() edge cases', () => {
+    it('stash/pop works correctly when only staged deletions exist', () => {
+        // Edge case: hasTrackedChanges returns true for staged deletions,
+        // but does git stash push actually stash a staged deletion?
+        // If stash doesn't capture it, stash pop could fail or restore wrong state.
+        const { local, remote } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        commitFile(local, 'b.txt', 'world', 'second');
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
+        // Remote adds a new file
+        const secondary = cloneAsSecondary(remote);
+        commitFile(secondary, 'remote-file.txt', 'remote', 'remote commit');
+        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
+        // Stage a deletion locally (without committing)
+        execFileSync('git', ['rm', 'b.txt'], { cwd: local, stdio: 'pipe' });
+        expect(hasTrackedChanges(local)).toBe(true);
+        expect(existsSync(join(local, 'b.txt'))).toBe(false);
+        const result = syncWithRemote(local);
+        expect(result.status).toBe('synced');
+        // After sync, the staged deletion should be restored
+        // (stash pop should bring back the staged rm state)
+        expect(existsSync(join(local, 'b.txt'))).toBe(false);
+        // Verify the deletion is still staged
+        const status = execFileSync('git', ['status', '--porcelain'], {
+            cwd: local, encoding: 'utf-8',
+        }).trim();
+        expect(status).toContain('b.txt');
+    });
+    it('handles sync when remote branch main does not exist yet (empty bare repo)', () => {
+        // User creates local repo and commits, but never pushed to remote.
+        // Remote is empty. fetch runwork main should fail.
+        const { local, remote } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        // Do NOT push -- remote has no 'main' branch
+        const result = syncWithRemote(local);
+        // fetch should fail because remote has no main branch
+        expect(result.status).toBe('sync-failed');
+        // But local repo should be intact
+        expect(readFileSync(join(local, 'a.txt'), 'utf-8')).toBe('hello');
+    });
+    it('leaves repo clean after auto-resolving conflicting unrelated histories', () => {
+        const { local, remote } = createTestRepo();
+        commitFile(local, 'shared.txt', 'local version\n', 'local init');
+        // Create conflicting remote history
+        const other = makeTempDir('other');
+        execFileSync('git', ['init', other]);
+        execFileSync('git', ['config', 'user.email', 'other@test.com'], { cwd: other });
+        execFileSync('git', ['config', 'user.name', 'Other'], { cwd: other });
+        commitFile(other, 'shared.txt', 'remote version\n', 'remote init');
+        execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: other });
+        execFileSync('git', ['push', 'origin', 'main'], { cwd: other, stdio: 'pipe' });
+        const result = syncWithRemote(local);
+        // Auto-resolved with -X theirs
+        expect(result.status).toBe('merged');
+        // Repo should NOT be in a rebase or merge state
+        expect(existsSync(join(local, '.git', 'MERGE_HEAD'))).toBe(false);
+        expect(existsSync(join(local, '.git', 'rebase-merge'))).toBe(false);
+        expect(existsSync(join(local, '.git', 'rebase-apply'))).toBe(false);
+        // Remote version wins
+        expect(readFileSync(join(local, 'shared.txt'), 'utf-8')).toBe('remote version\n');
+    });
+    it('handles merge conflict during rebase on related histories (same file edited both sides)', () => {
+        const { local, remote } = createTestRepo();
+        commitFile(local, 'shared.txt', 'original content\n', 'init');
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
+        // Remote modifies shared.txt
+        const secondary = cloneAsSecondary(remote);
+        writeFileSync(join(secondary, 'shared.txt'), 'remote edit line 1\nremote edit line 2\n');
+        execFileSync('git', ['add', 'shared.txt'], { cwd: secondary });
+        execFileSync('git', ['commit', '-m', 'remote edit'], { cwd: secondary });
+        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
+        // Local also modifies shared.txt (same area -> conflict)
+        writeFileSync(join(local, 'shared.txt'), 'local edit line 1\nlocal edit line 2\n');
+        execFileSync('git', ['add', 'shared.txt'], { cwd: local });
+        execFileSync('git', ['commit', '-m', 'local edit'], { cwd: local });
+        const result = syncWithRemote(local);
+        // Rebase should fail due to conflict, merge fallback should also have conflicts
+        // OR merge with --allow-unrelated-histories might succeed (unlikely for related histories)
+        // The key assertion: repo must NOT be left in broken state
+        expect(existsSync(join(local, '.git', 'MERGE_HEAD'))).toBe(false);
+        expect(existsSync(join(local, '.git', 'rebase-merge'))).toBe(false);
+        // Either merged or sync-failed, but never left in limbo
+        expect(['synced', 'merged', 'sync-failed']).toContain(result.status);
+    });
+    it('stash pop after sync-failed still restores dirty state', () => {
+        // If sync fails (fetch fails), dirty state should still be restored.
+        // But what if the stash was created and then the repo state changed
+        // (e.g., aborted rebase left things in weird state)?
+        const { local } = createTestRepo();
+        commitFile(local, 'a.txt', 'committed', 'init');
+        // Make dirty
+        writeFileSync(join(local, 'a.txt'), 'uncommitted change');
+        // Point to bad remote
+        const badPath = join(tmpdir(), 'nonexistent-' + Date.now());
+        execFileSync('git', ['remote', 'set-url', 'runwork', badPath], { cwd: local });
+        const result = syncWithRemote(local);
+        expect(result.status).toBe('sync-failed');
+        // The stash should have been popped successfully
+        expect(result.error).not.toBe('stash-conflict');
+        expect(readFileSync(join(local, 'a.txt'), 'utf-8')).toBe('uncommitted change');
+        // Stash list should be empty (stash was popped)
+        const stashList = execFileSync('git', ['stash', 'list'], {
+            cwd: local, encoding: 'utf-8',
+        }).trim();
+        expect(stashList).toBe('');
+    });
+    it('does not leave orphan stash entries on successful sync', () => {
+        const { local, remote } = createTestRepo();
+        commitFile(local, 'a.txt', 'hello', 'init');
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
+        // Remote adds a file
+        const secondary = cloneAsSecondary(remote);
+        commitFile(secondary, 'remote.txt', 'remote', 'remote commit');
+        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
+        // Make local dirty
+        writeFileSync(join(local, 'a.txt'), 'dirty');
+        const result = syncWithRemote(local);
+        expect(result.status).toBe('synced');
+        // Stash should be empty - no orphan stash entries
+        const stashList = execFileSync('git', ['stash', 'list'], {
+            cwd: local, encoding: 'utf-8',
+        }).trim();
+        expect(stashList).toBe('');
+    });
+});

package/dist/git/auto-commit.d.ts

@@ -1,3 +1,8 @@
 import type { ApiClient } from '../api/client.js';
-export declare function watchAndAutoCommit(directory: string, client: ApiClient, appId: string): Promise<void>;
+export declare function isIgnored(filePath: string): boolean;
+export declare function watchAndAutoCommit(directory: string, client: ApiClient, appId: string, callbacks?: {
+    onFileChange?: (relPath: string, pendingCount: number) => void;
+    onFastSync?: (count: number) => void;
+    onGitPush?: (count: number) => void;
+}): Promise<void>;
 export declare function stopAutoCommit(): Promise<void>;

package/dist/git/auto-commit.js

@@ -2,17 +2,19 @@ import { execFileSync } from 'child_process';
 import { readFileSync } from 'fs';
 import { watch } from 'chokidar';
 import { basename, join, relative } from 'path';
+import { dim, cyan, yellow } from '../ui/colors.js';
 let watcher = null;
 let fastSyncTimer = null;
 let gitTimer = null;
 let gitPushing = false;
 let gitPendingAfterPush = false;
+let activeCallbacks;
 // Files awaiting fast sync: path -> 'changed' | 'deleted'
 const pendingFastSync = new Map();
 // Track files the user actually touched during this session (for git)
 const changedFiles = new Set();
 const SKIP_DIRS = new Set(['node_modules', '.git', '.runwork']);
-const SKIP_FILES = new Set(['.dev.vars']);
+const SKIP_FILES = new Set(['.dev.vars', '.env']);
 const SKIP_EXTENSIONS = new Set(['.log']);
 // Binary extensions to skip in fast sync (git handles them fine)
 const BINARY_EXTENSIONS = new Set([
@@ -22,7 +24,7 @@ const BINARY_EXTENSIONS = new Set([
     '.zip', '.tar', '.gz', '.br',
     '.pdf', '.wasm',
 ]);
-function isIgnored(filePath) {
+export function isIgnored(filePath) {
     const name = basename(filePath);
     if (SKIP_DIRS.has(name))
         return true;
@@ -33,7 +35,8 @@ function isIgnored(filePath) {
         return true;
     return false;
 }
-export async function watchAndAutoCommit(directory, client, appId) {
+export async function watchAndAutoCommit(directory, client, appId, callbacks) {
+    activeCallbacks = callbacks;
     watcher = watch(directory, {
         ignored: isIgnored,
         persistent: true,
@@ -46,19 +49,20 @@ export async function watchAndAutoCommit(directory, client, appId) {
     const onFileChange = (filePath) => {
         const rel = relative(directory, filePath);
         if (changedFiles.size === 0) {
-            console.log(`Changed: ${rel}`);
+            console.log(`  ${dim('Changed:')} ${cyan(rel)}`);
         }
         else {
-            console.log(`Changed: ${rel} (+${changedFiles.size} pending)`);
+            console.log(`  ${dim('Changed:')} ${cyan(rel)} ${dim(`(+${changedFiles.size} pending)`)}`);
         }
         changedFiles.add(rel);
         pendingFastSync.set(rel, 'changed');
+        activeCallbacks?.onFileChange?.(rel, changedFiles.size);
         scheduleFastSync(directory, client, appId);
         scheduleGitCommit();
     };
     const onFileUnlink = (filePath) => {
         const rel = relative(directory, filePath);
-        console.log(`Deleted: ${rel}`);
+        console.log(`  ${dim('Deleted:')} ${cyan(rel)}`);
         changedFiles.add(rel);
         pendingFastSync.set(rel, 'deleted');
         scheduleFastSync(directory, client, appId);
@@ -109,11 +113,12 @@ async function executeFastSync(directory, client, appId) {
     const total = files.length + deletedFiles.length;
     try {
         await client.syncFiles(appId, files, deletedFiles.length > 0 ? deletedFiles : undefined);
-        console.log(`  Synced ${total} file(s) to preview.`);
+        console.log(dim(`  Synced ${total} file(s) to preview.`));
+        activeCallbacks?.onFastSync?.(total);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        console.warn(`  Fast sync failed (git will handle it): ${message}`);
+        console.warn(yellow(`  Fast sync failed (git will handle it): ${message}`));
     }
 }
 // ========================================
@@ -153,7 +158,7 @@ function commitAndPush() {
             }
         }
         // Check if anything was actually staged
-        const staged = execFileSync('git', ['diff', '--cached', '--name-only'], { encoding: 'utf-8' });
+        const staged = execFileSync('git', ['-c', 'core.quotePath=false', 'diff', '--cached', '--name-only'], { encoding: 'utf-8' });
         if (!staged.trim())
             return;
         const stagedFiles = staged.trim().split('\n').filter(Boolean);
@@ -169,8 +174,18 @@ function commitAndPush() {
                 execFileSync('git', ['rebase', '--abort'], { stdio: 'pipe' });
             }
             catch { /* no rebase in progress */ }
-            console.warn('Auto-sync: rebase failed, skipping push. Run `git pull --rebase runwork main` manually.');
-            return;
+            // Rebase fails when histories diverged (e.g. template update). Fall back to merge.
+            try {
+                execFileSync('git', ['merge', 'runwork/main', '--allow-unrelated-histories', '--no-edit'], { stdio: 'pipe' });
+            }
+            catch {
+                try {
+                    execFileSync('git', ['merge', '--abort'], { stdio: 'pipe' });
+                }
+                catch { /* no merge in progress */ }
+                console.warn(yellow('Auto-sync: merge failed, skipping push. Run `git pull --rebase runwork main` manually.'));
+                return;
+            }
         }
         try {
             execFileSync('git', ['rev-parse', '--abbrev-ref', '@{u}'], { stdio: 'pipe' });
@@ -179,11 +194,12 @@ function commitAndPush() {
         catch {
             execFileSync('git', ['push', '-u', 'runwork', 'main'], { stdio: 'pipe' });
         }
-        console.log(`  Pushed ${stagedFiles.length} file(s) to git.`);
+        console.log(dim(`  Pushed ${stagedFiles.length} file(s) to git.`));
+        activeCallbacks?.onGitPush?.(stagedFiles.length);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        console.warn(`Auto-sync failed: ${message}`);
+        console.warn(yellow(`Auto-sync failed: ${message}`));
     }
     finally {
         gitPushing = false;

package/dist/git/sync.d.ts

@@ -0,0 +1,15 @@
+export interface SyncResult {
+    status: 'synced' | 'merged' | 'sync-failed' | 'skipped';
+    pushed: boolean;
+    error?: string;
+}
+export declare function hasCommits(cwd: string): boolean;
+export declare function hasTrackedChanges(cwd: string): boolean;
+/**
+ * Sync local repository with the runwork remote.
+ *
+ * Strategy: fetch, then attempt rebase. If rebase fails (e.g. diverged
+ * histories after a template update), fall back to merge with
+ * --allow-unrelated-histories. Stash/pop around dirty working trees.
+ */
+export declare function syncWithRemote(cwd: string): SyncResult;