pushwork 1.0.0

package/dist/cli/commands.js

@@ -0,0 +1,794 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressMessages = void 0;
+exports.setupCommandContext = setupCommandContext;
+exports.safeRepoShutdown = safeRepoShutdown;
+exports.init = init;
+exports.sync = sync;
+exports.diff = diff;
+exports.status = status;
+exports.log = log;
+exports.checkout = checkout;
+exports.clone = clone;
+exports.url = url;
+exports.commit = commit;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const diffLib = __importStar(require("diff"));
+const core_1 = require("../core");
+const utils_1 = require("../utils");
+const config_1 = require("../config");
+const repo_factory_1 = require("../utils/repo-factory");
+/**
+ * Shared pre-action that ensures repository and sync engine are properly initialized
+ * This function always works, with or without network connectivity
+ */
+async function setupCommandContext(workingDir = process.cwd(), customSyncServer, customStorageId, enableNetwork = true) {
+    const resolvedPath = path.resolve(workingDir);
+    // Check if initialized
+    const syncToolDir = path.join(resolvedPath, ".pushwork");
+    if (!(await (0, utils_1.pathExists)(syncToolDir))) {
+        throw new Error('Directory not initialized for sync. Run "pushwork init" first.');
+    }
+    // Load configuration
+    const configManager = new config_1.ConfigManager(resolvedPath);
+    const config = await configManager.getMerged();
+    // Create repo with configurable network setting
+    const repo = await (0, repo_factory_1.createRepo)(resolvedPath, {
+        enableNetwork,
+        syncServer: customSyncServer,
+        syncServerStorageId: customStorageId,
+    });
+    // Create sync engine with configurable network sync
+    const syncEngine = new core_1.SyncEngine(repo, resolvedPath, config.defaults.exclude_patterns, enableNetwork, config.sync_server_storage_id);
+    return {
+        repo,
+        syncEngine,
+        config,
+        workingDir: resolvedPath,
+    };
+}
+/**
+ * Safely shutdown a repository with proper error handling
+ */
+async function safeRepoShutdown(repo, context) {
+    try {
+        await repo.shutdown();
+    }
+    catch (shutdownError) {
+        // WebSocket errors during shutdown are common and non-critical
+        // Only warn about unexpected shutdown errors
+        const errorMessage = shutdownError instanceof Error
+            ? shutdownError.message
+            : String(shutdownError);
+        if (!errorMessage.includes("WebSocket") &&
+            !errorMessage.includes("connection was established")) {
+            console.warn(`Warning: Repository shutdown failed${context ? ` (${context})` : ""}: ${shutdownError}`);
+        }
+    }
+}
+/**
+ * Common progress message helpers
+ */
+exports.ProgressMessages = {
+    // Setup messages
+    directoryFound: () => console.log(chalk_1.default.gray("  ✓ Sync directory found")),
+    configLoaded: () => console.log(chalk_1.default.gray("  ✓ Configuration loaded")),
+    repoConnected: () => console.log(chalk_1.default.gray("  ✓ Connected to repository")),
+    // Configuration display
+    syncServer: (server) => console.log(chalk_1.default.gray(`  ✓ Sync server: ${server}`)),
+    storageId: (id) => console.log(chalk_1.default.gray(`  ✓ Storage ID: ${id}`)),
+    rootUrl: (url) => console.log(chalk_1.default.gray(`  ✓ Root URL: ${url}`)),
+    // Operation completion
+    changesWritten: () => console.log(chalk_1.default.gray("  ✓ All changes written to disk")),
+    syncCompleted: (duration) => console.log(chalk_1.default.gray(`  ✓ Initial sync completed in ${duration}ms`)),
+    directoryStructureCreated: () => console.log(chalk_1.default.gray("  ✓ Created sync directory structure")),
+    configSaved: () => console.log(chalk_1.default.gray("  ✓ Saved configuration")),
+    repoCreated: () => console.log(chalk_1.default.gray("  ✓ Created Automerge repository")),
+};
+/**
+ * Show actual content diff for a changed file
+ */
+async function showContentDiff(change) {
+    try {
+        // Get old content (from snapshot/remote)
+        const oldContent = change.remoteContent || "";
+        // Get new content (current local)
+        const newContent = change.localContent || "";
+        // Convert binary content to string representation if needed
+        const oldText = typeof oldContent === "string"
+            ? oldContent
+            : `<binary content: ${oldContent.length} bytes>`;
+        const newText = typeof newContent === "string"
+            ? newContent
+            : `<binary content: ${newContent.length} bytes>`;
+        // Generate unified diff
+        const diffResult = diffLib.createPatch(change.path, oldText, newText, "previous", "current");
+        // Skip the header lines and process the diff
+        const lines = diffResult.split("\n").slice(4); // Skip index, ===, ---, +++ lines
+        if (lines.length === 0 || (lines.length === 1 && lines[0] === "")) {
+            console.log(chalk_1.default.gray("  (content identical)"));
+            return;
+        }
+        for (const line of lines) {
+            if (line.startsWith("@@")) {
+                // Hunk header
+                console.log(chalk_1.default.cyan(line));
+            }
+            else if (line.startsWith("+")) {
+                // Added line
+                console.log(chalk_1.default.green(line));
+            }
+            else if (line.startsWith("-")) {
+                // Removed line
+                console.log(chalk_1.default.red(line));
+            }
+            else if (line.startsWith(" ")) {
+                // Context line
+                console.log(chalk_1.default.gray(line));
+            }
+            else if (line === "") {
+                // Empty line
+                console.log("");
+            }
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.gray(`  (diff error: ${error})`));
+    }
+}
+/**
+ * Initialize sync in a directory
+ */
+async function init(targetPath, syncServer, syncServerStorageId) {
+    const spinner = (0, ora_1.default)("Starting initialization...").start();
+    try {
+        const resolvedPath = path.resolve(targetPath);
+        // Step 1: Directory setup
+        spinner.text = "Setting up directory structure...";
+        await (0, utils_1.ensureDirectoryExists)(resolvedPath);
+        // Check if already initialized
+        const syncToolDir = path.join(resolvedPath, ".pushwork");
+        if (await (0, utils_1.pathExists)(syncToolDir)) {
+            spinner.fail("Directory already initialized for sync");
+            return;
+        }
+        // Step 2: Create sync directories
+        spinner.text = "Creating .pushwork directory...";
+        await (0, utils_1.ensureDirectoryExists)(syncToolDir);
+        await (0, utils_1.ensureDirectoryExists)(path.join(syncToolDir, "automerge"));
+        exports.ProgressMessages.directoryStructureCreated();
+        // Step 3: Configuration setup
+        spinner.text = "Setting up configuration...";
+        const configManager = new config_1.ConfigManager(resolvedPath);
+        const defaultSyncServer = syncServer || "wss://sync3.automerge.org";
+        const defaultStorageId = syncServerStorageId || "3760df37-a4c6-4f66-9ecd-732039a9385d";
+        const config = {
+            sync_server: defaultSyncServer,
+            sync_server_storage_id: defaultStorageId,
+            sync_enabled: true,
+            defaults: {
+                exclude_patterns: [".git", "node_modules", "*.tmp", ".pushwork"],
+                large_file_threshold: "100MB",
+            },
+            diff: {
+                show_binary: false,
+            },
+            sync: {
+                move_detection_threshold: 0.8,
+                prompt_threshold: 0.5,
+                auto_sync: false,
+                parallel_operations: 4,
+            },
+        };
+        await configManager.save(config);
+        exports.ProgressMessages.configSaved();
+        exports.ProgressMessages.syncServer(defaultSyncServer);
+        exports.ProgressMessages.storageId(defaultStorageId);
+        // Step 4: Initialize Automerge repo and create root directory document
+        spinner.text = "Creating root directory document...";
+        const repo = await (0, repo_factory_1.createRepo)(resolvedPath, {
+            enableNetwork: true,
+            syncServer: syncServer,
+            syncServerStorageId: syncServerStorageId,
+        });
+        // Create the root directory document
+        const rootDoc = {
+            "@patchwork": { type: "folder" },
+            docs: [],
+        };
+        const rootHandle = repo.create(rootDoc);
+        exports.ProgressMessages.repoCreated();
+        exports.ProgressMessages.rootUrl(rootHandle.url);
+        // Step 5: Scan existing files
+        spinner.text = "Scanning existing files...";
+        const syncEngine = new core_1.SyncEngine(repo, resolvedPath, config.defaults.exclude_patterns, true, // Network sync enabled for init
+        config.sync_server_storage_id);
+        // Get file count for progress
+        const dirEntries = await fs.readdir(resolvedPath, { withFileTypes: true });
+        const fileCount = dirEntries.filter((dirent) => dirent.isFile()).length;
+        if (fileCount > 0) {
+            console.log(chalk_1.default.gray(`  ✓ Found ${fileCount} existing files`));
+            spinner.text = `Creating initial snapshot with ${fileCount} files...`;
+        }
+        else {
+            spinner.text = "Creating initial empty snapshot...";
+        }
+        // Step 6: Set the root directory URL before creating initial snapshot
+        await syncEngine.setRootDirectoryUrl(rootHandle.url);
+        // Step 7: Create initial snapshot
+        spinner.text = "Creating initial snapshot...";
+        const startTime = Date.now();
+        await syncEngine.sync(false);
+        const duration = Date.now() - startTime;
+        exports.ProgressMessages.syncCompleted(duration);
+        // Step 8: Ensure all Automerge operations are flushed to disk
+        spinner.text = "Flushing changes to disk...";
+        await safeRepoShutdown(repo, "init");
+        exports.ProgressMessages.changesWritten();
+        spinner.succeed(`Initialized sync in ${chalk_1.default.green(resolvedPath)}`);
+        console.log(`\n${chalk_1.default.bold("🎉 Sync Directory Created!")}`);
+        console.log(`  📁 Directory: ${chalk_1.default.blue(resolvedPath)}`);
+        console.log(`  🔗 Sync server: ${chalk_1.default.blue(defaultSyncServer)}`);
+        console.log(`\n${chalk_1.default.green("Initialization complete!")} Run ${chalk_1.default.cyan("pushwork sync")} to start syncing.`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to initialize: ${error}`);
+        throw error;
+    }
+}
+/**
+ * Run bidirectional sync
+ */
+async function sync(options) {
+    const spinner = (0, ora_1.default)("Starting sync operation...").start();
+    try {
+        // Step 1: Setup shared context
+        spinner.text = "Setting up sync context...";
+        const { repo, syncEngine, config, workingDir } = await setupCommandContext();
+        exports.ProgressMessages.directoryFound();
+        exports.ProgressMessages.configLoaded();
+        exports.ProgressMessages.syncServer(config?.sync_server || "wss://sync3.automerge.org");
+        exports.ProgressMessages.repoConnected();
+        // Show root directory URL for context
+        const syncStatus = await syncEngine.getStatus();
+        if (syncStatus.snapshot?.rootDirectoryUrl) {
+            exports.ProgressMessages.rootUrl(syncStatus.snapshot.rootDirectoryUrl);
+        }
+        if (options.dryRun) {
+            // Dry run mode - detailed preview
+            spinner.text = "Analyzing changes (dry run)...";
+            const startTime = Date.now();
+            const preview = await syncEngine.previewChanges();
+            const analysisTime = Date.now() - startTime;
+            spinner.succeed("Change analysis completed");
+            console.log(`\n${chalk_1.default.bold("📊 Change Analysis")} (${analysisTime}ms):`);
+            console.log(chalk_1.default.gray(`  Directory: ${workingDir}`));
+            console.log(chalk_1.default.gray(`  Analysis time: ${analysisTime}ms`));
+            if (preview.changes.length === 0 && preview.moves.length === 0) {
+                console.log(`\n${chalk_1.default.green("✨ No changes detected")} - everything is in sync!`);
+                return;
+            }
+            console.log(`\n${chalk_1.default.bold("📋 Summary:")}`);
+            console.log(`  ${preview.summary}`);
+            if (preview.changes.length > 0) {
+                const localChanges = preview.changes.filter((c) => c.changeType === "local_only" || c.changeType === "both_changed").length;
+                const remoteChanges = preview.changes.filter((c) => c.changeType === "remote_only" || c.changeType === "both_changed").length;
+                const conflicts = preview.changes.filter((c) => c.changeType === "both_changed").length;
+                console.log(`\n${chalk_1.default.bold("📁 File Changes:")} (${preview.changes.length} total)`);
+                if (localChanges > 0) {
+                    console.log(`  ${chalk_1.default.green("📤")} Local changes: ${localChanges}`);
+                }
+                if (remoteChanges > 0) {
+                    console.log(`  ${chalk_1.default.blue("📥")} Remote changes: ${remoteChanges}`);
+                }
+                if (conflicts > 0) {
+                    console.log(`  ${chalk_1.default.yellow("⚠️")} Conflicts: ${conflicts}`);
+                }
+                console.log(`\n${chalk_1.default.bold("📄 Changed Files:")}`);
+                for (const change of preview.changes.slice(0, 10)) {
+                    // Show first 10
+                    const typeIcon = change.changeType === "local_only"
+                        ? chalk_1.default.green("📤")
+                        : change.changeType === "remote_only"
+                            ? chalk_1.default.blue("📥")
+                            : change.changeType === "both_changed"
+                                ? chalk_1.default.yellow("⚠️")
+                                : chalk_1.default.gray("➖");
+                    console.log(`  ${typeIcon} ${change.path}`);
+                }
+                if (preview.changes.length > 10) {
+                    console.log(`  ${chalk_1.default.gray(`... and ${preview.changes.length - 10} more files`)}`);
+                }
+            }
+            if (preview.moves.length > 0) {
+                console.log(`\n${chalk_1.default.bold("🔄 Potential Moves:")} (${preview.moves.length})`);
+                for (const move of preview.moves.slice(0, 5)) {
+                    // Show first 5
+                    const confidence = move.confidence === "auto"
+                        ? chalk_1.default.green("Auto")
+                        : move.confidence === "prompt"
+                            ? chalk_1.default.yellow("Prompt")
+                            : chalk_1.default.red("Low");
+                    console.log(`  🔄 ${move.fromPath} → ${move.toPath} (${confidence})`);
+                }
+                if (preview.moves.length > 5) {
+                    console.log(`  ${chalk_1.default.gray(`... and ${preview.moves.length - 5} more moves`)}`);
+                }
+            }
+            console.log(`\n${chalk_1.default.cyan("ℹ️  Run without --dry-run to apply these changes")}`);
+        }
+        else {
+            // Actual sync operation
+            spinner.text = "Detecting changes...";
+            const startTime = Date.now();
+            const result = await syncEngine.sync(false);
+            const totalTime = Date.now() - startTime;
+            if (result.success) {
+                spinner.succeed(`Sync completed in ${totalTime}ms`);
+                console.log(`\n${chalk_1.default.bold("✅ Sync Results:")}`);
+                console.log(`  📄 Files changed: ${chalk_1.default.yellow(result.filesChanged)}`);
+                console.log(`  📁 Directories changed: ${chalk_1.default.yellow(result.directoriesChanged)}`);
+                console.log(`  ⏱️  Total time: ${chalk_1.default.gray(totalTime + "ms")}`);
+                if (result.warnings.length > 0) {
+                    console.log(`\n${chalk_1.default.yellow("⚠️  Warnings:")} (${result.warnings.length})`);
+                    for (const warning of result.warnings.slice(0, 5)) {
+                        console.log(`  ${chalk_1.default.yellow("⚠️")} ${warning}`);
+                    }
+                    if (result.warnings.length > 5) {
+                        console.log(`  ${chalk_1.default.gray(`... and ${result.warnings.length - 5} more warnings`)}`);
+                    }
+                }
+                if (result.filesChanged === 0 && result.directoriesChanged === 0) {
+                    console.log(`\n${chalk_1.default.green("✨ Everything already in sync!")}`);
+                }
+                // Ensure all changes are flushed to disk
+                spinner.text = "Flushing changes to disk...";
+                await safeRepoShutdown(repo, "sync");
+                exports.ProgressMessages.changesWritten();
+            }
+            else {
+                spinner.fail("Sync completed with errors");
+                console.log(`\n${chalk_1.default.red("❌ Sync Errors:")} (${result.errors.length})`);
+                for (const error of result.errors.slice(0, 5)) {
+                    console.log(`  ${chalk_1.default.red("❌")} ${error.path}: ${error.error.message}`);
+                }
+                if (result.errors.length > 5) {
+                    console.log(`  ${chalk_1.default.gray(`... and ${result.errors.length - 5} more errors`)}`);
+                }
+                if (result.filesChanged > 0 || result.directoriesChanged > 0) {
+                    console.log(`\n${chalk_1.default.yellow("⚠️  Partial sync completed:")}`);
+                    console.log(`  📄 Files changed: ${result.filesChanged}`);
+                    console.log(`  📁 Directories changed: ${result.directoriesChanged}`);
+                }
+                // Still try to flush any partial changes
+                await safeRepoShutdown(repo, "sync-error");
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail(`Sync failed: ${error}`);
+        throw error;
+    }
+}
+/**
+ * Show differences between local and remote
+ */
+async function diff(targetPath = ".", options) {
+    try {
+        // Setup shared context with network disabled for diff check
+        const { repo, syncEngine } = await setupCommandContext(targetPath, undefined, undefined, false);
+        const preview = await syncEngine.previewChanges();
+        if (options.nameOnly) {
+            // Show only file names
+            for (const change of preview.changes) {
+                console.log(change.path);
+            }
+            return;
+        }
+        // Show root directory URL for context
+        const diffStatus = await syncEngine.getStatus();
+        if (diffStatus.snapshot?.rootDirectoryUrl) {
+            console.log(chalk_1.default.gray(`Root URL: ${diffStatus.snapshot.rootDirectoryUrl}`));
+            console.log("");
+        }
+        if (preview.changes.length === 0) {
+            console.log(chalk_1.default.green("No changes detected"));
+            return;
+        }
+        console.log(chalk_1.default.bold("Differences:"));
+        for (const change of preview.changes) {
+            const typeLabel = change.changeType === "local_only"
+                ? chalk_1.default.green("[LOCAL]")
+                : change.changeType === "remote_only"
+                    ? chalk_1.default.blue("[REMOTE]")
+                    : change.changeType === "both_changed"
+                        ? chalk_1.default.yellow("[CONFLICT]")
+                        : chalk_1.default.gray("[NO CHANGE]");
+            console.log(`\n${typeLabel} ${change.path}`);
+            if (options.tool) {
+                console.log(`  Use "${options.tool}" to view detailed diff`);
+            }
+            else {
+                // Show actual diff content
+                await showContentDiff(change);
+            }
+        }
+        // Cleanup repo resources
+        await safeRepoShutdown(repo, "diff");
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Diff failed: ${error}`));
+        throw error;
+    }
+}
+/**
+ * Show sync status
+ */
+async function status() {
+    try {
+        const spinner = (0, ora_1.default)("Loading sync status...").start();
+        // Setup shared context with network disabled for status check
+        const { repo, syncEngine, workingDir } = await setupCommandContext(process.cwd(), undefined, undefined, false);
+        const syncStatus = await syncEngine.getStatus();
+        spinner.stop();
+        console.log(chalk_1.default.bold("📊 Sync Status Report"));
+        console.log(`${"=".repeat(50)}`);
+        // Directory information
+        console.log(`\n${chalk_1.default.bold("📁 Directory Information:")}`);
+        console.log(`  📂 Path: ${chalk_1.default.blue(workingDir)}`);
+        console.log(`  🔧 Config: ${path.join(workingDir, ".pushwork")}`);
+        // Show root directory URL if available
+        if (syncStatus.snapshot?.rootDirectoryUrl) {
+            console.log(`  🔗 Root URL: ${chalk_1.default.cyan(syncStatus.snapshot.rootDirectoryUrl)}`);
+        }
+        else {
+            console.log(`  🔗 Root URL: ${chalk_1.default.yellow("Not set")}`);
+        }
+        // Sync timing
+        if (syncStatus.lastSync) {
+            const timeSince = Date.now() - syncStatus.lastSync.getTime();
+            const timeAgo = timeSince < 60000
+                ? `${Math.floor(timeSince / 1000)}s ago`
+                : timeSince < 3600000
+                    ? `${Math.floor(timeSince / 60000)}m ago`
+                    : `${Math.floor(timeSince / 3600000)}h ago`;
+            console.log(`\n${chalk_1.default.bold("⏱️  Sync Timing:")}`);
+            console.log(`  🕐 Last sync: ${chalk_1.default.green(syncStatus.lastSync.toLocaleString())}`);
+            console.log(`  ⏳ Time since: ${chalk_1.default.gray(timeAgo)}`);
+        }
+        else {
+            console.log(`\n${chalk_1.default.bold("⏱️  Sync Timing:")}`);
+            console.log(`  🕐 Last sync: ${chalk_1.default.yellow("Never synced")}`);
+            console.log(`  💡 Run ${chalk_1.default.cyan("pushwork sync")} to perform initial sync`);
+        }
+        // Change status
+        console.log(`\n${chalk_1.default.bold("📝 Change Status:")}`);
+        if (syncStatus.hasChanges) {
+            console.log(`  📄 Pending changes: ${chalk_1.default.yellow(syncStatus.changeCount)}`);
+            console.log(`  🔄 Status: ${chalk_1.default.yellow("Sync needed")}`);
+            console.log(`  💡 Run ${chalk_1.default.cyan("pushwork diff")} to see details`);
+        }
+        else {
+            console.log(`  📄 Pending changes: ${chalk_1.default.green("None")}`);
+            console.log(`  ✅ Status: ${chalk_1.default.green("Up to date")}`);
+        }
+        // Configuration
+        console.log(`\n${chalk_1.default.bold("⚙️  Configuration:")}`);
+        const statusConfigManager2 = new config_1.ConfigManager(workingDir);
+        const statusConfig2 = await statusConfigManager2.load();
+        if (statusConfig2?.sync_server) {
+            console.log(`  🔗 Sync server: ${chalk_1.default.blue(statusConfig2.sync_server)}`);
+        }
+        else {
+            console.log(`  🔗 Sync server: ${chalk_1.default.blue("wss://sync3.automerge.org")} (default)`);
+        }
+        console.log(`  ⚡ Auto sync: ${statusConfig2?.sync?.auto_sync
+            ? chalk_1.default.green("Enabled")
+            : chalk_1.default.gray("Disabled")}`);
+        // Snapshot information
+        if (syncStatus.snapshot) {
+            const fileCount = syncStatus.snapshot.files.size;
+            const dirCount = syncStatus.snapshot.directories.size;
+            console.log(`\n${chalk_1.default.bold("📊 Repository Statistics:")}`);
+            console.log(`  📄 Tracked files: ${chalk_1.default.yellow(fileCount)}`);
+            console.log(`  📁 Tracked directories: ${chalk_1.default.yellow(dirCount)}`);
+            console.log(`  🏷️  Snapshot timestamp: ${chalk_1.default.gray(new Date(syncStatus.snapshot.timestamp).toLocaleString())}`);
+        }
+        // Quick actions
+        console.log(`\n${chalk_1.default.bold("🚀 Quick Actions:")}`);
+        if (syncStatus.hasChanges) {
+            console.log(`  ${chalk_1.default.cyan("pushwork diff")}     - View pending changes`);
+            console.log(`  ${chalk_1.default.cyan("pushwork sync")}     - Apply changes`);
+        }
+        else {
+            console.log(`  ${chalk_1.default.cyan("pushwork sync")}     - Check for remote changes`);
+        }
+        console.log(`  ${chalk_1.default.cyan("pushwork log")}      - View sync history`);
+        // Cleanup repo resources
+        await safeRepoShutdown(repo, "status");
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`❌ Status check failed: ${error}`));
+        throw error;
+    }
+}
+/**
+ * Show sync history
+ */
+async function log(targetPath = ".", options) {
+    try {
+        // Setup shared context with network disabled for log check
+        const { repo: logRepo, syncEngine: logSyncEngine, workingDir, } = await setupCommandContext(targetPath, undefined, undefined, false);
+        const logStatus = await logSyncEngine.getStatus();
+        if (logStatus.snapshot?.rootDirectoryUrl) {
+            console.log(chalk_1.default.gray(`Root URL: ${logStatus.snapshot.rootDirectoryUrl}`));
+            console.log("");
+        }
+        // TODO: Implement history tracking and display
+        // For now, show basic information
+        console.log(chalk_1.default.bold("Sync History:"));
+        // Check for snapshot files
+        const snapshotPath = path.join(workingDir, ".pushwork", "snapshot.json");
+        if (await (0, utils_1.pathExists)(snapshotPath)) {
+            const stats = await fs.stat(snapshotPath);
+            if (options.oneline) {
+                console.log(`${stats.mtime.toISOString()} - Last sync`);
+            }
+            else {
+                console.log(`Last sync: ${chalk_1.default.green(stats.mtime.toISOString())}`);
+                console.log(`Snapshot size: ${stats.size} bytes`);
+            }
+        }
+        else {
+            console.log(chalk_1.default.yellow("No sync history found"));
+        }
+        // Cleanup repo resources
+        await safeRepoShutdown(logRepo, "log");
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Log failed: ${error}`));
+        throw error;
+    }
+}
+/**
+ * Checkout/restore from previous sync
+ */
+async function checkout(syncId, targetPath = ".", options) {
+    try {
+        // Setup shared context
+        const { workingDir } = await setupCommandContext(targetPath);
+        // TODO: Implement checkout functionality
+        // This would involve:
+        // 1. Finding the sync with the given ID
+        // 2. Restoring file states from that sync
+        // 3. Updating the snapshot
+        console.log(chalk_1.default.yellow(`Checkout functionality not yet implemented`));
+        console.log(`Would restore to sync: ${syncId}`);
+        console.log(`Target path: ${workingDir}`);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Checkout failed: ${error}`));
+        throw error;
+    }
+}
+/**
+ * Clone an existing synced directory from an AutomergeUrl
+ */
+async function clone(rootUrl, targetPath, options) {
+    const spinner = (0, ora_1.default)("Starting clone operation...").start();
+    try {
+        const resolvedPath = path.resolve(targetPath);
+        // Step 1: Directory setup
+        spinner.text = "Setting up target directory...";
+        // Check if directory exists and handle --force
+        if (await (0, utils_1.pathExists)(resolvedPath)) {
+            const files = await fs.readdir(resolvedPath);
+            if (files.length > 0 && !options.force) {
+                spinner.fail("Target directory is not empty. Use --force to overwrite.");
+                return;
+            }
+        }
+        else {
+            await (0, utils_1.ensureDirectoryExists)(resolvedPath);
+        }
+        // Check if already initialized
+        const syncToolDir = path.join(resolvedPath, ".pushwork");
+        if (await (0, utils_1.pathExists)(syncToolDir)) {
+            if (!options.force) {
+                spinner.fail("Directory already initialized for sync. Use --force to overwrite.");
+                return;
+            }
+            // Clean up existing sync directory
+            await fs.rm(syncToolDir, { recursive: true, force: true });
+        }
+        console.log(chalk_1.default.gray("  ✓ Target directory prepared"));
+        // Step 2: Create sync directories
+        spinner.text = "Creating .pushwork directory...";
+        await (0, utils_1.ensureDirectoryExists)(syncToolDir);
+        await (0, utils_1.ensureDirectoryExists)(path.join(syncToolDir, "automerge"));
+        exports.ProgressMessages.directoryStructureCreated();
+        // Step 3: Configuration setup
+        spinner.text = "Setting up configuration...";
+        const configManager = new config_1.ConfigManager(resolvedPath);
+        const defaultSyncServer = options.syncServer || "wss://sync3.automerge.org";
+        const defaultStorageId = options.syncServerStorageId || "3760df37-a4c6-4f66-9ecd-732039a9385d";
+        const config = {
+            sync_server: defaultSyncServer,
+            sync_server_storage_id: defaultStorageId,
+            sync_enabled: true,
+            defaults: {
+                exclude_patterns: [".git", "node_modules", "*.tmp", ".pushwork"],
+                large_file_threshold: "100MB",
+            },
+            diff: {
+                show_binary: false,
+            },
+            sync: {
+                move_detection_threshold: 0.8,
+                prompt_threshold: 0.5,
+                auto_sync: false,
+                parallel_operations: 4,
+            },
+        };
+        await configManager.save(config);
+        exports.ProgressMessages.configSaved();
+        exports.ProgressMessages.syncServer(defaultSyncServer);
+        exports.ProgressMessages.storageId(defaultStorageId);
+        // Step 4: Initialize Automerge repo and connect to root directory
+        spinner.text = "Connecting to root directory document...";
+        const repo = await (0, repo_factory_1.createRepo)(resolvedPath, {
+            enableNetwork: true,
+            syncServer: options.syncServer,
+            syncServerStorageId: options.syncServerStorageId,
+        });
+        exports.ProgressMessages.repoCreated();
+        exports.ProgressMessages.rootUrl(rootUrl);
+        // Step 5: Initialize sync engine and pull existing structure
+        spinner.text = "Downloading directory structure...";
+        const syncEngine = new core_1.SyncEngine(repo, resolvedPath, config.defaults.exclude_patterns, true, // Network sync enabled for clone
+        defaultStorageId);
+        // Set the root directory URL to connect to the cloned repository
+        await syncEngine.setRootDirectoryUrl(rootUrl);
+        // Sync to pull the existing directory structure and files
+        const startTime = Date.now();
+        await syncEngine.sync(false);
+        const duration = Date.now() - startTime;
+        console.log(chalk_1.default.gray(`  ✓ Directory sync completed in ${duration}ms`));
+        // Ensure all changes are flushed to disk
+        spinner.text = "Flushing changes to disk...";
+        await safeRepoShutdown(repo, "clone");
+        exports.ProgressMessages.changesWritten();
+        spinner.succeed(`Cloned sync directory to ${chalk_1.default.green(resolvedPath)}`);
+        console.log(`\n${chalk_1.default.bold("📂 Directory Cloned!")}`);
+        console.log(`  📁 Directory: ${chalk_1.default.blue(resolvedPath)}`);
+        console.log(`  🔗 Root URL: ${chalk_1.default.cyan(rootUrl)}`);
+        console.log(`  🔗 Sync server: ${chalk_1.default.blue(defaultSyncServer)}`);
+        console.log(`\n${chalk_1.default.green("Clone complete!")} Run ${chalk_1.default.cyan("pushwork sync")} to stay in sync.`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to clone: ${error}`);
+        throw error;
+    }
+}
+/**
+ * Get the root URL for the current pushwork repository
+ */
+async function url(targetPath = ".") {
+    try {
+        const resolvedPath = path.resolve(targetPath);
+        // Check if initialized
+        const syncToolDir = path.join(resolvedPath, ".pushwork");
+        if (!(await (0, utils_1.pathExists)(syncToolDir))) {
+            console.error(chalk_1.default.red("Directory not initialized for sync"));
+            console.error(`Run ${chalk_1.default.cyan("pushwork init .")} to get started`);
+            process.exit(1);
+        }
+        // Load the snapshot directly to get the URL without all the verbose output
+        const snapshotPath = path.join(syncToolDir, "snapshot.json");
+        if (!(await (0, utils_1.pathExists)(snapshotPath))) {
+            console.error(chalk_1.default.red("No snapshot found"));
+            console.error(chalk_1.default.gray("The repository may not be properly initialized"));
+            process.exit(1);
+        }
+        const snapshotData = await fs.readFile(snapshotPath, "utf-8");
+        const snapshot = JSON.parse(snapshotData);
+        if (snapshot.rootDirectoryUrl) {
+            // Output just the URL for easy use in scripts
+            console.log(snapshot.rootDirectoryUrl);
+        }
+        else {
+            console.error(chalk_1.default.red("No root URL found in snapshot"));
+            console.error(chalk_1.default.gray("The repository may not be properly initialized"));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Failed to get URL: ${error}`));
+        process.exit(1);
+    }
+}
+async function commit(targetPath, dryRun = false) {
+    const spinner = (0, ora_1.default)("Starting commit operation...").start();
+    let repo;
+    try {
+        // Setup shared context with network disabled for local-only commit
+        spinner.text = "Setting up commit context...";
+        const context = await setupCommandContext(targetPath, undefined, undefined, false);
+        repo = context.repo;
+        const syncEngine = context.syncEngine;
+        spinner.succeed("Connected to repository");
+        // Run local commit only
+        spinner.text = "Committing local changes...";
+        const startTime = Date.now();
+        const result = await syncEngine.commitLocal(dryRun);
+        const duration = Date.now() - startTime;
+        if (repo) {
+            await safeRepoShutdown(repo, "commit");
+        }
+        spinner.succeed(`Commit completed in ${duration}ms`);
+        // Display results
+        console.log(chalk_1.default.green("\n✅ Commit Results:"));
+        console.log(`  📄 Files committed: ${result.filesChanged}`);
+        console.log(`  📁 Directories committed: ${result.directoriesChanged}`);
+        console.log(`  ⏱️  Total time: ${duration}ms`);
+        if (result.warnings.length > 0) {
+            console.log(chalk_1.default.yellow("\n⚠️  Warnings:"));
+            result.warnings.forEach((warning) => console.log(chalk_1.default.yellow(`  • ${warning}`)));
+        }
+        if (result.errors.length > 0) {
+            console.log(chalk_1.default.red("\n❌ Errors:"));
+            result.errors.forEach((error) => console.log(chalk_1.default.red(`  • ${error.operation} at ${error.path}: ${error.error.message}`)));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.gray("\n💡 Run 'pushwork push' to upload to sync server"));
+    }
+    catch (error) {
+        if (repo) {
+            await safeRepoShutdown(repo, "commit-error");
+        }
+        spinner.fail(`Commit failed: ${error}`);
+        console.error(chalk_1.default.red(`Error: ${error}`));
+        process.exit(1);
+    }
+}
+// TODO: Add push and pull commands later
+//# sourceMappingURL=commands.js.map