pushwork 1.0.4 → 1.0.7

package/dist/core/sync-engine.js

@@ -34,7 +34,6 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SyncEngine = void 0;
-const automerge_repo_1 = require("@automerge/automerge-repo");
 const A = __importStar(require("@automerge/automerge"));
 const types_1 = require("../types");
 const utils_1 = require("../utils");
@@ -43,20 +42,27 @@ const network_sync_1 = require("../utils/network-sync");
 const snapshot_1 = require("./snapshot");
 const change_detection_1 = require("./change-detection");
 const move_detection_1 = require("./move-detection");
+const output_1 = require("../utils/output");
+/**
+ * Post-sync delay constants for network propagation
+ * These delays allow the WebSocket protocol to propagate peer changes after
+ * our changes reach the server. waitForSync only ensures OUR changes reached
+ * the server, not that we've RECEIVED changes from other peers.
+ * TODO: remove need for this to exist.
+ */
+const POST_SYNC_DELAY_MS = 200; // After we pushed changes
 /**
  * Bidirectional sync engine implementing two-phase sync
  */
 class SyncEngine {
-    constructor(repo, rootPath, excludePatterns = [], networkSyncEnabled = true, syncServerStorageId) {
+    constructor(repo, rootPath, config) {
         this.repo = repo;
         this.rootPath = rootPath;
-        this.networkSyncEnabled = true;
         this.handlesToWaitOn = [];
+        this.config = config;
         this.snapshotManager = new snapshot_1.SnapshotManager(rootPath);
-        this.changeDetector = new change_detection_1.ChangeDetector(repo, rootPath, excludePatterns);
-        this.moveDetector = new move_detection_1.MoveDetector();
-        this.networkSyncEnabled = networkSyncEnabled;
-        this.syncServerStorageId = syncServerStorageId;
+        this.changeDetector = new change_detection_1.ChangeDetector(repo, rootPath, config.exclude_patterns);
+        this.moveDetector = new move_detection_1.MoveDetector(config.sync.move_detection_threshold);
     }
     /**
      * Determine if content should be treated as text for Automerge text operations
@@ -81,8 +87,7 @@ class SyncEngine {
     /**
      * Commit local changes only (no network sync)
      */
-    async commitLocal(dryRun = false) {
-        console.log(`🚀 Starting local commit process (dryRun: ${dryRun})`);
+    async commitLocal() {
         const result = {
             success: false,
             filesChanged: 0,
@@ -92,35 +97,16 @@ class SyncEngine {
         };
         try {
             // Load current snapshot
-            console.log(`📸 Loading current snapshot...`);
             let snapshot = await this.snapshotManager.load();
             if (!snapshot) {
-                console.log(`📸 No snapshot found, creating empty one`);
                 snapshot = this.snapshotManager.createEmpty();
             }
-            else {
-                console.log(`📸 Snapshot loaded with ${snapshot.files.size} files`);
-                if (snapshot.rootDirectoryUrl) {
-                    console.log(`🔗 Root directory URL: ${snapshot.rootDirectoryUrl}`);
-                }
-            }
-            // Backup snapshot before starting
-            if (!dryRun) {
-                console.log(`💾 Backing up snapshot...`);
-                await this.snapshotManager.backup();
-            }
             // Detect all changes
-            console.log(`🔍 Detecting changes...`);
             const changes = await this.changeDetector.detectChanges(snapshot);
-            console.log(`🔍 Found ${changes.length} changes`);
             // Detect moves
-            console.log(`📦 Detecting moves...`);
-            const { moves, remainingChanges } = await this.moveDetector.detectMoves(changes, snapshot, this.rootPath);
-            console.log(`📦 Found ${moves.length} moves, ${remainingChanges.length} remaining changes`);
+            const { moves, remainingChanges } = await this.moveDetector.detectMoves(changes, snapshot);
             // Apply local changes only (no network sync)
-            console.log(`💾 Committing local changes...`);
-            const commitResult = await this.pushLocalChanges(remainingChanges, moves, snapshot, dryRun);
-            console.log(`💾 Commit complete: ${commitResult.filesChanged} files changed`);
+            const commitResult = await this.pushLocalChanges(remainingChanges, moves, snapshot);
             result.filesChanged += commitResult.filesChanged;
             result.directoriesChanged += commitResult.directoriesChanged;
             result.errors.push(...commitResult.errors);
@@ -128,18 +114,14 @@ class SyncEngine {
             // Touch root directory if any changes were made
             const hasChanges = result.filesChanged > 0 || result.directoriesChanged > 0;
             if (hasChanges) {
-                await this.touchRootDirectory(snapshot, dryRun);
-            }
-            // Save updated snapshot if not dry run
-            if (!dryRun) {
-                await this.snapshotManager.save(snapshot);
+                await this.touchRootDirectory(snapshot);
             }
+            // Save updated snapshot
+            await this.snapshotManager.save(snapshot);
             result.success = result.errors.length === 0;
-            console.log(`💾 Local commit ${result.success ? "completed" : "failed"}`);
             return result;
         }
         catch (error) {
-            console.error(`❌ Local commit failed: ${error}`);
             result.errors.push({
                 path: this.rootPath,
                 operation: "commitLocal",
@@ -153,65 +135,43 @@ class SyncEngine {
     /**
      * Run full bidirectional sync
      */
-    async sync(dryRun = false) {
-        const syncStartTime = Date.now();
-        const timings = {};
+    async sync() {
         const result = {
             success: false,
             filesChanged: 0,
             directoriesChanged: 0,
             errors: [],
             warnings: [],
+            timings: {},
         };
         // Reset handles to wait on
         this.handlesToWaitOn = [];
         try {
             // Load current snapshot
-            const t0 = Date.now();
-            let snapshot = await this.snapshotManager.load();
-            timings["load_snapshot"] = Date.now() - t0;
-            if (!snapshot) {
-                snapshot = this.snapshotManager.createEmpty();
-            }
-            // Backup snapshot before starting
-            const t1 = Date.now();
-            if (!dryRun) {
-                await this.snapshotManager.backup();
-            }
-            timings["backup_snapshot"] = Date.now() - t1;
+            const snapshot = (await this.snapshotManager.load()) ||
+                this.snapshotManager.createEmpty();
             // Detect all changes
-            const t2 = Date.now();
             const changes = await this.changeDetector.detectChanges(snapshot);
-            timings["detect_changes"] = Date.now() - t2;
             // Detect moves
-            const t3 = Date.now();
-            const { moves, remainingChanges } = await this.moveDetector.detectMoves(changes, snapshot, this.rootPath);
-            timings["detect_moves"] = Date.now() - t3;
-            if (changes.length > 0) {
-                console.log(`🔄 Syncing ${changes.length} changes...`);
-            }
+            const { moves, remainingChanges } = await this.moveDetector.detectMoves(changes, snapshot);
             // Phase 1: Push local changes to remote
-            const t4 = Date.now();
-            const phase1Result = await this.pushLocalChanges(remainingChanges, moves, snapshot, dryRun);
-            timings["phase1_push"] = Date.now() - t4;
+            const phase1Result = await this.pushLocalChanges(remainingChanges, moves, snapshot);
             result.filesChanged += phase1Result.filesChanged;
             result.directoriesChanged += phase1Result.directoriesChanged;
             result.errors.push(...phase1Result.errors);
             result.warnings.push(...phase1Result.warnings);
             // Always wait for network sync when enabled (not just when local changes exist)
             // This is critical for clone scenarios where we need to pull remote changes
-            const t5 = Date.now();
-            if (!dryRun && this.networkSyncEnabled) {
+            if (this.config.sync_enabled) {
                 try {
                     // If we have a root directory URL, wait for it to sync
                     if (snapshot.rootDirectoryUrl) {
-                        const rootHandle = await this.repo.find(snapshot.rootDirectoryUrl);
+                        const rootDirUrl = snapshot.rootDirectoryUrl;
+                        const rootHandle = await this.repo.find(rootDirUrl);
                         this.handlesToWaitOn.push(rootHandle);
                     }
                     if (this.handlesToWaitOn.length > 0) {
-                        const tWaitStart = Date.now();
-                        await (0, network_sync_1.waitForSync)(this.handlesToWaitOn, (0, network_sync_1.getSyncServerStorageId)(this.syncServerStorageId));
-                        timings["network_sync"] = Date.now() - tWaitStart;
+                        await (0, network_sync_1.waitForSync)(this.handlesToWaitOn, this.config.sync_server_storage_id);
                         // CRITICAL: Wait a bit after our changes reach the server to allow
                         // time for WebSocket to deliver OTHER peers' changes to us.
                         // waitForSync only ensures OUR changes reached the server, not that
@@ -221,30 +181,22 @@ class SyncEngine {
                         // each other due to timing races.
                         //
                         // Optimization: Only wait if we pushed changes (shorter delay if no changes)
-                        const tDelayStart = Date.now();
-                        const delayMs = phase1Result.filesChanged > 0 ? 200 : 100;
-                        await new Promise((resolve) => setTimeout(resolve, delayMs));
-                        timings["post_sync_delay"] = Date.now() - tDelayStart;
+                        await new Promise((resolve) => setTimeout(resolve, POST_SYNC_DELAY_MS));
                     }
                 }
                 catch (error) {
-                    console.error(`❌ Network sync failed: ${error}`);
+                    output_1.out.taskLine(`Network sync failed: ${error}`, true);
                     result.warnings.push(`Network sync failed: ${error}`);
                 }
             }
-            timings["total_network"] = Date.now() - t5;
             // Re-detect remote changes after network sync to ensure fresh state
             // This fixes race conditions where we detect changes before server propagation
             // NOTE: We DON'T update snapshot heads yet - that would prevent detecting remote changes!
-            const t6 = Date.now();
             const freshChanges = await this.changeDetector.detectChanges(snapshot);
             const freshRemoteChanges = freshChanges.filter((c) => c.changeType === types_1.ChangeType.REMOTE_ONLY ||
                 c.changeType === types_1.ChangeType.BOTH_CHANGED);
-            timings["redetect_changes"] = Date.now() - t6;
             // Phase 2: Pull remote changes to local using fresh detection
-            const t7 = Date.now();
-            const phase2Result = await this.pullRemoteChanges(freshRemoteChanges, snapshot, dryRun);
-            timings["phase2_pull"] = Date.now() - t7;
+            const phase2Result = await this.pullRemoteChanges(freshRemoteChanges, snapshot);
             result.filesChanged += phase2Result.filesChanged;
             result.directoriesChanged += phase2Result.directoriesChanged;
             result.errors.push(...phase2Result.errors);
@@ -252,71 +204,47 @@ class SyncEngine {
             // CRITICAL FIX: Update snapshot heads AFTER pulling remote changes
             // This ensures that change detection can find remote changes, and we only
             // update the snapshot after the filesystem is in sync with the documents
-            const t8 = Date.now();
-            if (!dryRun) {
-                // Update file document heads
-                for (const [filePath, snapshotEntry] of snapshot.files.entries()) {
-                    try {
-                        const handle = await this.repo.find(snapshotEntry.url);
-                        const currentHeads = handle.heads();
-                        if (!A.equals(currentHeads, snapshotEntry.head)) {
-                            // Update snapshot with current heads after pulling changes
-                            snapshot.files.set(filePath, {
-                                ...snapshotEntry,
-                                head: currentHeads,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        // Handle might not exist if file was deleted, skip
-                        console.warn(`Could not update heads for ${filePath}: ${error}`);
+            // Update file document heads
+            for (const [filePath, snapshotEntry] of snapshot.files.entries()) {
+                try {
+                    const handle = await this.repo.find(snapshotEntry.url);
+                    const currentHeads = handle.heads();
+                    if (!A.equals(currentHeads, snapshotEntry.head)) {
+                        // Update snapshot with current heads after pulling changes
+                        snapshot.files.set(filePath, {
+                            ...snapshotEntry,
+                            head: currentHeads,
+                        });
                     }
                 }
-                // Update directory document heads
-                for (const [dirPath, snapshotEntry] of snapshot.directories.entries()) {
-                    try {
-                        const handle = await this.repo.find(snapshotEntry.url);
-                        const currentHeads = handle.heads();
-                        if (!A.equals(currentHeads, snapshotEntry.head)) {
-                            // Update snapshot with current heads after pulling changes
-                            snapshot.directories.set(dirPath, {
-                                ...snapshotEntry,
-                                head: currentHeads,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        // Handle might not exist if directory was deleted, skip
-                        console.warn(`Could not update heads for directory ${dirPath}: ${error}`);
+                catch (error) {
+                    // Handle might not exist if file was deleted
+                }
+            }
+            // Update directory document heads
+            for (const [dirPath, snapshotEntry] of snapshot.directories.entries()) {
+                try {
+                    const handle = await this.repo.find(snapshotEntry.url);
+                    const currentHeads = handle.heads();
+                    if (!A.equals(currentHeads, snapshotEntry.head)) {
+                        // Update snapshot with current heads after pulling changes
+                        snapshot.directories.set(dirPath, {
+                            ...snapshotEntry,
+                            head: currentHeads,
+                        });
                     }
                 }
+                catch (error) {
+                    // Handle might not exist if directory was deleted
+                }
             }
-            timings["update_snapshot_heads"] = Date.now() - t8;
             // Touch root directory if any changes were made during sync
-            const t9 = Date.now();
             const hasChanges = result.filesChanged > 0 || result.directoriesChanged > 0;
             if (hasChanges) {
-                await this.touchRootDirectory(snapshot, dryRun);
+                await this.touchRootDirectory(snapshot);
             }
-            timings["touch_root"] = Date.now() - t9;
             // Save updated snapshot if not dry run
-            const t10 = Date.now();
-            if (!dryRun) {
-                await this.snapshotManager.save(snapshot);
-            }
-            timings["save_snapshot"] = Date.now() - t10;
-            // Output timing breakdown if enabled via environment variable
-            if (process.env.PUSHWORK_TIMING === "1") {
-                const totalTime = Date.now() - syncStartTime;
-                console.error("\n⏱️  Sync Timing Breakdown:");
-                for (const [key, ms] of Object.entries(timings)) {
-                    const pct = ((ms / totalTime) * 100).toFixed(1);
-                    console.error(`  ${key.padEnd(25)} ${ms.toString().padStart(5)}ms (${pct}%)`);
-                }
-                console.error(`  ${"TOTAL".padEnd(25)} ${totalTime
-                    .toString()
-                    .padStart(5)}ms (100.0%)\n`);
-            }
+            await this.snapshotManager.save(snapshot);
             result.success = result.errors.length === 0;
             return result;
         }
@@ -333,7 +261,7 @@ class SyncEngine {
     /**
      * Phase 1: Push local changes to Automerge documents
      */
-    async pushLocalChanges(changes, moves, snapshot, dryRun) {
+    async pushLocalChanges(changes, moves, snapshot) {
         const result = {
             success: true,
             filesChanged: 0,
@@ -341,26 +269,19 @@ class SyncEngine {
             errors: [],
             warnings: [],
         };
-        // Process moves first
+        // Process moves first - all detected moves are applied
         for (const move of moves) {
-            if (this.moveDetector.shouldAutoApply(move)) {
-                try {
-                    await this.applyMoveToRemote(move, snapshot, dryRun);
-                    result.filesChanged++;
-                }
-                catch (error) {
-                    result.errors.push({
-                        path: move.fromPath,
-                        operation: "move",
-                        error: error,
-                        recoverable: true,
-                    });
-                }
+            try {
+                await this.applyMoveToRemote(move, snapshot);
+                result.filesChanged++;
             }
-            else if (this.moveDetector.shouldPromptUser(move)) {
-                // Instead of creating a persistent loop, perform delete+create semantics
-                // so the working tree converges even without auto-apply.
-                result.warnings.push(`Potential move detected: ${this.moveDetector.formatMove(move)} (${Math.round(move.similarity * 100)}% similar)`);
+            catch (error) {
+                result.errors.push({
+                    path: move.fromPath,
+                    operation: "move",
+                    error: error,
+                    recoverable: true,
+                });
             }
         }
         // Process local changes
@@ -368,7 +289,7 @@ class SyncEngine {
             c.changeType === types_1.ChangeType.BOTH_CHANGED);
         for (const change of localChanges) {
             try {
-                await this.applyLocalChangeToRemote(change, snapshot, dryRun);
+                await this.applyLocalChangeToRemote(change, snapshot);
                 result.filesChanged++;
             }
             catch (error) {
@@ -385,7 +306,7 @@ class SyncEngine {
     /**
      * Phase 2: Pull remote changes to local filesystem
      */
-    async pullRemoteChanges(changes, snapshot, dryRun) {
+    async pullRemoteChanges(changes, snapshot) {
         const result = {
             success: true,
             filesChanged: 0,
@@ -400,7 +321,7 @@ class SyncEngine {
         const sortedChanges = this.sortChangesByDependency(remoteChanges);
         for (const change of sortedChanges) {
             try {
-                await this.applyRemoteChangeToLocal(change, snapshot, dryRun);
+                await this.applyRemoteChangeToLocal(change, snapshot);
                 result.filesChanged++;
             }
             catch (error) {
@@ -417,33 +338,29 @@ class SyncEngine {
     /**
      * Apply local file change to remote Automerge document
      */
-    async applyLocalChangeToRemote(change, snapshot, dryRun) {
+    async applyLocalChangeToRemote(change, snapshot) {
         const snapshotEntry = snapshot.files.get(change.path);
         // CRITICAL: Check for null explicitly, not falsy values
         // Empty strings "" and empty Uint8Array are valid file content!
         if (change.localContent === null) {
             // File was deleted locally
             if (snapshotEntry) {
-                console.log(`🗑️  ${change.path}`);
-                await this.deleteRemoteFile(snapshotEntry.url, dryRun, snapshot, change.path);
+                await this.deleteRemoteFile(snapshotEntry.url, snapshot, change.path);
                 // Remove from directory document
-                await this.removeFileFromDirectory(snapshot, change.path, dryRun);
-                if (!dryRun) {
-                    this.snapshotManager.removeFileEntry(snapshot, change.path);
-                }
+                await this.removeFileFromDirectory(snapshot, change.path);
+                this.snapshotManager.removeFileEntry(snapshot, change.path);
             }
             return;
         }
         if (!snapshotEntry) {
             // New file
-            console.log(`➕ ${change.path}`);
-            const handle = await this.createRemoteFile(change, dryRun);
-            if (!dryRun && handle) {
-                await this.addFileToDirectory(snapshot, change.path, handle.url, dryRun);
+            const handle = await this.createRemoteFile(change);
+            if (handle) {
+                await this.addFileToDirectory(snapshot, change.path, handle.url);
                 // CRITICAL FIX: Update snapshot with heads AFTER adding to directory
                 // The addFileToDirectory call above may have changed the document heads
                 this.snapshotManager.updateFileEntry(snapshot, change.path, {
-                    path: (0, utils_1.normalizePath)(this.rootPath + "/" + change.path),
+                    path: (0, utils_1.joinAndNormalizePath)(this.rootPath, change.path),
                     url: handle.url,
                     head: handle.heads(),
                     extension: (0, utils_1.getFileExtension)(change.path),
@@ -453,15 +370,14 @@ class SyncEngine {
         }
         else {
             // Update existing file
-            console.log(`📝 ${change.path}`);
-            await this.updateRemoteFile(snapshotEntry.url, change.localContent, dryRun, snapshot, change.path);
+            await this.updateRemoteFile(snapshotEntry.url, change.localContent, snapshot, change.path);
         }
     }
     /**
      * Apply remote change to local filesystem
      */
-    async applyRemoteChangeToLocal(change, snapshot, dryRun) {
-        const localPath = (0, utils_1.normalizePath)(this.rootPath + "/" + change.path);
+    async applyRemoteChangeToLocal(change, snapshot) {
+        const localPath = (0, utils_1.joinAndNormalizePath)(this.rootPath, change.path);
         if (!change.remoteHead) {
             throw new Error(`No remote head found for remote change to ${change.path}`);
         }
@@ -469,130 +385,114 @@ class SyncEngine {
         // Empty strings "" and empty Uint8Array are valid file content!
         if (change.remoteContent === null) {
             // File was deleted remotely
-            console.log(`🗑️  ${change.path}`);
-            if (!dryRun) {
-                await (0, utils_1.removePath)(localPath);
-                this.snapshotManager.removeFileEntry(snapshot, change.path);
-            }
+            await (0, utils_1.removePath)(localPath);
+            this.snapshotManager.removeFileEntry(snapshot, change.path);
             return;
         }
         // Create or update local file
-        if (change.changeType === types_1.ChangeType.REMOTE_ONLY) {
-            console.log(`⬇️  ${change.path}`);
+        await (0, utils_1.writeFileContent)(localPath, change.remoteContent);
+        // Update or create snapshot entry for this file
+        const snapshotEntry = snapshot.files.get(change.path);
+        if (snapshotEntry) {
+            // Update existing entry
+            snapshotEntry.head = change.remoteHead;
         }
         else {
-            console.log(`🔀 ${change.path}`);
-        }
-        if (!dryRun) {
-            await (0, utils_1.writeFileContent)(localPath, change.remoteContent);
-            // Update or create snapshot entry for this file
-            const snapshotEntry = snapshot.files.get(change.path);
-            if (snapshotEntry) {
-                // Update existing entry
-                snapshotEntry.head = change.remoteHead;
-            }
-            else {
-                // Create new snapshot entry for newly discovered remote file
-                // We need to find the remote file's URL from the directory hierarchy
-                if (snapshot.rootDirectoryUrl) {
-                    try {
-                        const fileEntry = await this.findFileInDirectoryHierarchy(snapshot.rootDirectoryUrl, change.path);
-                        if (fileEntry) {
-                            this.snapshotManager.updateFileEntry(snapshot, change.path, {
-                                path: localPath,
-                                url: fileEntry.url,
-                                head: change.remoteHead,
-                                extension: (0, utils_1.getFileExtension)(change.path),
-                                mimeType: (0, utils_1.getEnhancedMimeType)(change.path),
-                            });
-                        }
-                    }
-                    catch (error) {
-                        console.warn(`Failed to update snapshot for remote file ${change.path}: ${error}`);
+            // Create new snapshot entry for newly discovered remote file
+            // We need to find the remote file's URL from the directory hierarchy
+            if (snapshot.rootDirectoryUrl) {
+                try {
+                    const fileEntry = await (0, utils_1.findFileInDirectoryHierarchy)(this.repo, snapshot.rootDirectoryUrl, change.path);
+                    if (fileEntry) {
+                        this.snapshotManager.updateFileEntry(snapshot, change.path, {
+                            path: localPath,
+                            url: fileEntry.url,
+                            head: change.remoteHead,
+                            extension: (0, utils_1.getFileExtension)(change.path),
+                            mimeType: (0, utils_1.getEnhancedMimeType)(change.path),
+                        });
                     }
                 }
+                catch (error) {
+                    // Failed to update snapshot - file may have been deleted
+                    output_1.out.taskLine(`Warning: Failed to update snapshot for remote file ${change.path}`, true);
+                }
             }
         }
     }
     /**
      * Apply move to remote documents
      */
-    async applyMoveToRemote(move, snapshot, dryRun) {
+    async applyMoveToRemote(move, snapshot) {
         const fromEntry = snapshot.files.get(move.fromPath);
         if (!fromEntry)
             return;
         // Parse paths
-        const fromParts = move.fromPath.split("/");
-        const fromFileName = fromParts.pop() || "";
-        const fromDirPath = fromParts.join("/");
         const toParts = move.toPath.split("/");
         const toFileName = toParts.pop() || "";
         const toDirPath = toParts.join("/");
-        if (!dryRun) {
-            // 1) Remove file entry from old directory document
-            if (move.fromPath !== move.toPath) {
-                await this.removeFileFromDirectory(snapshot, move.fromPath, dryRun);
-            }
-            // 2) Ensure destination directory document exists and add file entry there
-            const destDirUrl = await this.ensureDirectoryDocument(snapshot, toDirPath, dryRun);
-            await this.addFileToDirectory(snapshot, move.toPath, fromEntry.url, dryRun);
-            // 3) Update the FileDocument name and content to match new location/state
-            try {
-                const handle = await this.repo.find(fromEntry.url);
-                const heads = fromEntry.head;
-                // Update both name and content (if content changed during move)
-                if (heads && heads.length > 0) {
-                    handle.changeAt(heads, (doc) => {
-                        doc.name = toFileName;
-                        // If new content is provided, update it (handles move + modification case)
-                        if (move.newContent !== undefined) {
-                            const isText = this.isTextContent(move.newContent);
-                            if (isText && typeof move.newContent === "string") {
-                                (0, automerge_repo_1.updateText)(doc, ["content"], move.newContent);
-                            }
-                            else {
-                                doc.content = move.newContent;
-                            }
+        // 1) Remove file entry from old directory document
+        if (move.fromPath !== move.toPath) {
+            await this.removeFileFromDirectory(snapshot, move.fromPath);
+        }
+        // 2) Ensure destination directory document exists and add file entry there
+        await this.ensureDirectoryDocument(snapshot, toDirPath);
+        await this.addFileToDirectory(snapshot, move.toPath, fromEntry.url);
+        // 3) Update the FileDocument name and content to match new location/state
+        try {
+            const handle = await this.repo.find(fromEntry.url);
+            const heads = fromEntry.head;
+            // Update both name and content (if content changed during move)
+            if (heads && heads.length > 0) {
+                handle.changeAt(heads, (doc) => {
+                    doc.name = toFileName;
+                    // If new content is provided, update it (handles move + modification case)
+                    if (move.newContent !== undefined) {
+                        if (typeof move.newContent === "string") {
+                            doc.content = new A.ImmutableString(move.newContent);
                         }
-                    });
-                }
-                else {
-                    handle.change((doc) => {
-                        doc.name = toFileName;
-                        // If new content is provided, update it (handles move + modification case)
-                        if (move.newContent !== undefined) {
-                            const isText = this.isTextContent(move.newContent);
-                            if (isText && typeof move.newContent === "string") {
-                                (0, automerge_repo_1.updateText)(doc, ["content"], move.newContent);
-                            }
-                            else {
-                                doc.content = move.newContent;
-                            }
+                        else {
+                            doc.content = move.newContent;
                         }
-                    });
-                }
-                // Track file handle for network sync
-                this.handlesToWaitOn.push(handle);
+                    }
+                });
             }
-            catch (e) {
-                console.warn(`Failed to update file name for move ${move.fromPath} -> ${move.toPath}: ${e}`);
+            else {
+                handle.change((doc) => {
+                    doc.name = toFileName;
+                    // If new content is provided, update it (handles move + modification case)
+                    if (move.newContent !== undefined) {
+                        if (typeof move.newContent === "string") {
+                            doc.content = new A.ImmutableString(move.newContent);
+                        }
+                        else {
+                            doc.content = move.newContent;
+                        }
+                    }
+                });
             }
-            // 4) Update snapshot entries
-            this.snapshotManager.removeFileEntry(snapshot, move.fromPath);
-            this.snapshotManager.updateFileEntry(snapshot, move.toPath, {
-                ...fromEntry,
-                path: (0, utils_1.normalizePath)(this.rootPath + "/" + move.toPath),
-                head: fromEntry.head, // will be updated later when heads advance
-            });
+            // Track file handle for network sync
+            this.handlesToWaitOn.push(handle);
+        }
+        catch (e) {
+            // Failed to update file name - file may have been deleted
+            output_1.out.taskLine(`Warning: Failed to rename ${move.fromPath} to ${move.toPath}`, true);
         }
+        // 4) Update snapshot entries
+        this.snapshotManager.removeFileEntry(snapshot, move.fromPath);
+        this.snapshotManager.updateFileEntry(snapshot, move.toPath, {
+            ...fromEntry,
+            path: (0, utils_1.joinAndNormalizePath)(this.rootPath, move.toPath),
+            head: fromEntry.head, // will be updated later when heads advance
+        });
     }
     /**
      * Create new remote file document
      */
-    async createRemoteFile(change, dryRun) {
+    async createRemoteFile(change) {
         // CRITICAL: Check for null explicitly, not falsy values
         // Empty strings "" and empty Uint8Array are valid file content!
-        if (dryRun || change.localContent === null)
+        if (change.localContent === null)
             return null;
         const isText = this.isTextContent(change.localContent);
         // Create initial document structure
@@ -601,16 +501,20 @@ class SyncEngine {
             name: change.path.split("/").pop() || "",
             extension: (0, utils_1.getFileExtension)(change.path),
             mimeType: (0, utils_1.getEnhancedMimeType)(change.path),
-            content: isText ? "" : change.localContent, // Empty string for text, actual content for binary
+            content: isText
+                ? new A.ImmutableString("")
+                : typeof change.localContent === "string"
+                    ? new A.ImmutableString(change.localContent)
+                    : change.localContent, // Empty ImmutableString for text, wrap strings for safety, actual content for binary
             metadata: {
                 permissions: 0o644,
             },
         };
         const handle = this.repo.create(fileDoc);
-        // For text files, use updateText to set the content properly
+        // For text files, use ImmutableString for better performance
         if (isText && typeof change.localContent === "string") {
             handle.change((doc) => {
-                (0, automerge_repo_1.updateText)(doc, ["content"], change.localContent);
+                doc.content = new A.ImmutableString(change.localContent);
             });
         }
         // Always track newly created files for network sync
@@ -621,9 +525,7 @@ class SyncEngine {
     /**
      * Update existing remote file document
      */
-    async updateRemoteFile(url, content, dryRun, snapshot, filePath) {
-        if (dryRun)
-            return;
+    async updateRemoteFile(url, content, snapshot, filePath) {
         const handle = await this.repo.find(url);
         // Check if content actually changed before tracking for sync
         const doc = await handle.doc();
@@ -642,7 +544,6 @@ class SyncEngine {
         if (!contentChanged) {
             // Content is identical, but we've updated the snapshot heads above
             // This prevents fresh change detection from seeing stale heads
-            console.log(`🔍 Content is identical, but we've updated the snapshot heads above`);
             return;
         }
         const heads = snapshotEntry?.head;
@@ -650,16 +551,15 @@ class SyncEngine {
             throw new Error(`No heads found for ${url}`);
         }
         handle.changeAt(heads, (doc) => {
-            const isText = this.isTextContent(content);
-            if (isText && typeof content === "string") {
-                (0, automerge_repo_1.updateText)(doc, ["content"], content);
+            if (typeof content === "string") {
+                doc.content = new A.ImmutableString(content);
             }
             else {
                 doc.content = content;
             }
         });
         // Update snapshot with new heads after content change
-        if (!dryRun && snapshotEntry) {
+        if (snapshotEntry) {
             snapshot.files.set(filePath, {
                 ...snapshotEntry,
                 head: handle.heads(),
@@ -671,9 +571,7 @@ class SyncEngine {
     /**
      * Delete remote file document
      */
-    async deleteRemoteFile(url, dryRun, snapshot, filePath) {
-        if (dryRun)
-            return;
+    async deleteRemoteFile(url, snapshot, filePath) {
         // In Automerge, we don't actually delete documents
         // They become orphaned and will be garbage collected
         // For now, we just mark them as deleted by clearing content
@@ -685,27 +583,26 @@ class SyncEngine {
         }
         if (heads) {
             handle.changeAt(heads, (doc) => {
-                doc.content = "";
+                doc.content = new A.ImmutableString("");
             });
         }
         else {
             handle.change((doc) => {
-                doc.content = "";
+                doc.content = new A.ImmutableString("");
             });
         }
     }
     /**
      * Add file entry to appropriate directory document (maintains hierarchy)
      */
-    async addFileToDirectory(snapshot, filePath, fileUrl, dryRun) {
-        if (dryRun || !snapshot.rootDirectoryUrl)
+    async addFileToDirectory(snapshot, filePath, fileUrl) {
+        if (!snapshot.rootDirectoryUrl)
             return;
         const pathParts = filePath.split("/");
         const fileName = pathParts.pop() || "";
         const directoryPath = pathParts.join("/");
         // Get or create the parent directory document
-        const parentDirUrl = await this.ensureDirectoryDocument(snapshot, directoryPath, dryRun);
-        console.log(`🔗 Adding ${fileName} (${fileUrl}) to directory ${parentDirUrl} (path: ${directoryPath})`);
+        const parentDirUrl = await this.ensureDirectoryDocument(snapshot, directoryPath);
         const dirHandle = await this.repo.find(parentDirUrl);
         let didChange = false;
         const snapshotEntry = snapshot.directories.get(directoryPath);
@@ -749,7 +646,7 @@ class SyncEngine {
      * Ensure directory document exists for the given path, creating hierarchy as needed
      * First checks for existing shared directories before creating new ones
      */
-    async ensureDirectoryDocument(snapshot, directoryPath, dryRun) {
+    async ensureDirectoryDocument(snapshot, directoryPath) {
         // Root directory case
         if (!directoryPath || directoryPath === "") {
             return snapshot.rootDirectoryUrl;
@@ -764,7 +661,7 @@ class SyncEngine {
         const currentDirName = pathParts.pop() || "";
         const parentPath = pathParts.join("/");
         // Ensure parent directory exists first (recursive)
-        const parentDirUrl = await this.ensureDirectoryDocument(snapshot, parentPath, dryRun);
+        const parentDirUrl = await this.ensureDirectoryDocument(snapshot, parentPath);
         // DISCOVERY: Check if directory already exists in parent on server
         try {
             const parentHandle = await this.repo.find(parentDirUrl);
@@ -778,25 +675,22 @@ class SyncEngine {
                         const childDirHandle = await this.repo.find(existingDirEntry.url);
                         const childHeads = childDirHandle.heads();
                         // Update snapshot with discovered directory using validated heads
-                        if (!dryRun) {
-                            this.snapshotManager.updateDirectoryEntry(snapshot, directoryPath, {
-                                path: (0, utils_1.normalizePath)(this.rootPath + "/" + directoryPath),
-                                url: existingDirEntry.url,
-                                head: childHeads,
-                                entries: [],
-                            });
-                        }
+                        this.snapshotManager.updateDirectoryEntry(snapshot, directoryPath, {
+                            path: (0, utils_1.joinAndNormalizePath)(this.rootPath, directoryPath),
+                            url: existingDirEntry.url,
+                            head: childHeads,
+                            entries: [],
+                        });
                         return existingDirEntry.url;
                     }
                     catch (resolveErr) {
-                        console.warn(`Failed to resolve child directory ${currentDirName} at ${directoryPath}: ${resolveErr}`);
-                        // Fall through to create a fresh directory document
+                        // Failed to resolve directory - fall through to create a fresh directory document
                     }
                 }
             }
         }
         catch (error) {
-            console.warn(`Failed to check for existing directory ${currentDirName}: ${error}`);
+            // Failed to check for existing directory - will create new one
         }
         // CREATE: Directory doesn't exist, create new one
         const dirDoc = {
@@ -820,32 +714,30 @@ class SyncEngine {
             }
         });
         // Track directory handles for sync
-        if (!dryRun) {
-            this.handlesToWaitOn.push(dirHandle);
-            if (didChange) {
-                this.handlesToWaitOn.push(parentHandle);
-                // CRITICAL FIX: Update parent directory heads in snapshot immediately
-                // This prevents stale head issues when parent directory is modified
-                const parentSnapshotEntry = snapshot.directories.get(parentPath);
-                if (parentSnapshotEntry) {
-                    parentSnapshotEntry.head = parentHandle.heads();
-                }
-            }
-            // Update snapshot with new directory
-            this.snapshotManager.updateDirectoryEntry(snapshot, directoryPath, {
-                path: (0, utils_1.normalizePath)(this.rootPath + "/" + directoryPath),
-                url: dirHandle.url,
-                head: dirHandle.heads(),
-                entries: [],
-            });
-        }
+        this.handlesToWaitOn.push(dirHandle);
+        if (didChange) {
+            this.handlesToWaitOn.push(parentHandle);
+            // CRITICAL FIX: Update parent directory heads in snapshot immediately
+            // This prevents stale head issues when parent directory is modified
+            const parentSnapshotEntry = snapshot.directories.get(parentPath);
+            if (parentSnapshotEntry) {
+                parentSnapshotEntry.head = parentHandle.heads();
+            }
+        }
+        // Update snapshot with new directory
+        this.snapshotManager.updateDirectoryEntry(snapshot, directoryPath, {
+            path: (0, utils_1.joinAndNormalizePath)(this.rootPath, directoryPath),
+            url: dirHandle.url,
+            head: dirHandle.heads(),
+            entries: [],
+        });
         return dirHandle.url;
     }
     /**
      * Remove file entry from directory document
      */
-    async removeFileFromDirectory(snapshot, filePath, dryRun) {
-        if (dryRun || !snapshot.rootDirectoryUrl)
+    async removeFileFromDirectory(snapshot, filePath) {
+        if (!snapshot.rootDirectoryUrl)
             return;
         const pathParts = filePath.split("/");
         const fileName = pathParts.pop() || "";
@@ -858,7 +750,7 @@ class SyncEngine {
         else {
             const existingDir = snapshot.directories.get(directoryPath);
             if (!existingDir) {
-                console.warn(`Directory ${directoryPath} not found in snapshot for file removal`);
+                // Directory not found - file may already be removed
                 return;
             }
             parentDirUrl = existingDir.url;
@@ -876,7 +768,7 @@ class SyncEngine {
                     if (indexToRemove !== -1) {
                         doc.docs.splice(indexToRemove, 1);
                         didChange = true;
-                        console.log(`🗑️  Removed ${fileName} from directory ${directoryPath || "root"}`);
+                        output_1.out.taskLine(`Removed ${fileName} from ${(0, utils_1.formatRelativePath)(directoryPath) || "root"}`);
                     }
                 });
             }
@@ -886,7 +778,7 @@ class SyncEngine {
                     if (indexToRemove !== -1) {
                         doc.docs.splice(indexToRemove, 1);
                         didChange = true;
-                        console.log(`🗑️  Removed ${fileName} from directory ${directoryPath || "root"}`);
+                        output_1.out.taskLine(`Removed ${fileName} from ${(0, utils_1.formatRelativePath)(directoryPath) || "root"}`);
                     }
                 });
             }
@@ -897,43 +789,10 @@ class SyncEngine {
             }
         }
         catch (error) {
-            console.warn(`Failed to remove ${fileName} from directory ${directoryPath || "root"}: ${error}`);
+            // Failed to remove from directory - re-throw for caller to handle
             throw error;
         }
     }
-    /**
-     * Find a file in the directory hierarchy by path
-     */
-    async findFileInDirectoryHierarchy(directoryUrl, filePath) {
-        try {
-            const pathParts = filePath.split("/");
-            let currentDirUrl = directoryUrl;
-            // Navigate through directories to find the parent directory
-            for (let i = 0; i < pathParts.length - 1; i++) {
-                const dirName = pathParts[i];
-                const dirHandle = await this.repo.find(currentDirUrl);
-                const dirDoc = await dirHandle.doc();
-                if (!dirDoc)
-                    return null;
-                const subDirEntry = dirDoc.docs.find((entry) => entry.name === dirName && entry.type === "folder");
-                if (!subDirEntry)
-                    return null;
-                currentDirUrl = subDirEntry.url;
-            }
-            // Now look for the file in the final directory
-            const fileName = pathParts[pathParts.length - 1];
-            const finalDirHandle = await this.repo.find(currentDirUrl);
-            const finalDirDoc = await finalDirHandle.doc();
-            if (!finalDirDoc)
-                return null;
-            const fileEntry = finalDirDoc.docs.find((entry) => entry.name === fileName && entry.type === "file");
-            return fileEntry || null;
-        }
-        catch (error) {
-            console.warn(`Failed to find file ${filePath} in directory hierarchy: ${error}`);
-            return null;
-        }
-    }
     /**
      * Sort changes by dependency order
      */
@@ -979,7 +838,7 @@ class SyncEngine {
             };
         }
         const changes = await this.changeDetector.detectChanges(snapshot);
-        const { moves } = await this.moveDetector.detectMoves(changes, snapshot, this.rootPath);
+        const { moves } = await this.moveDetector.detectMoves(changes, snapshot);
         const summary = this.generateChangeSummary(changes, moves);
         return { changes, moves, summary };
     }
@@ -1013,8 +872,8 @@ class SyncEngine {
     /**
      * Update the lastSyncAt timestamp on the root directory document
      */
-    async touchRootDirectory(snapshot, dryRun) {
-        if (dryRun || !snapshot.rootDirectoryUrl) {
+    async touchRootDirectory(snapshot) {
+        if (!snapshot.rootDirectoryUrl) {
             return;
         }
         try {
@@ -1039,10 +898,9 @@ class SyncEngine {
             if (snapshotEntry) {
                 snapshotEntry.head = rootHandle.heads();
             }
-            console.log(`🕒 Updated root directory lastSyncAt to ${new Date(timestamp).toISOString()}`);
         }
         catch (error) {
-            console.warn(`Failed to update root directory lastSyncAt: ${error}`);
+            // Failed to update root directory timestamp
         }
     }
 }