pushwork 1.0.0

package/src/cli/index.ts

@@ -0,0 +1,2 @@
+// CLI commands
+export * from "./commands";

package/src/cli.ts

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import chalk from "chalk";
+import {
+  init,
+  clone,
+  sync,
+  diff,
+  status,
+  log,
+  checkout,
+  commit,
+  url,
+} from "./cli/commands";
+
+/**
+ * Wrapper for command actions with consistent error handling
+ */
+function withErrorHandling<T extends any[], R>(
+  fn: (...args: T) => Promise<R>
+): (...args: T) => Promise<void> {
+  return async (...args: T): Promise<void> => {
+    try {
+      await fn(...args);
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error}`));
+      process.exit(1);
+    }
+  };
+}
+
+const program = new Command();
+
+program
+  .name("pushwork")
+  .description("Bidirectional directory synchronization using Automerge CRDTs")
+  .version("1.0.0");
+
+// Init command
+program
+  .command("init")
+  .description("Initialize sync in directory")
+  .argument("<path>", "Directory path to initialize")
+  .option(
+    "--sync-server <url>",
+    "Custom sync server URL (must be used with --sync-server-storage-id)"
+  )
+  .option(
+    "--sync-server-storage-id <id>",
+    "Custom sync server storage ID (must be used with --sync-server)"
+  )
+  .addHelpText(
+    "after",
+    `
+Examples:
+  pushwork init ./my-folder
+  pushwork init ./my-folder --sync-server ws://localhost:3030 --sync-server-storage-id 1d89eba7-f7a4-4e8e-80f2-5f4e2406f507
+  
+Note: Custom sync server options must always be used together.`
+  )
+  .action(
+    withErrorHandling(async (path: string, options) => {
+      // Validate that both sync server options are provided together
+      const hasSyncServer = !!options.syncServer;
+      const hasSyncServerStorageId = !!options.syncServerStorageId;
+
+      if (hasSyncServer && !hasSyncServerStorageId) {
+        console.error(
+          chalk.red("Error: --sync-server requires --sync-server-storage-id")
+        );
+        console.error(
+          chalk.yellow("Both arguments must be provided together.")
+        );
+        process.exit(1);
+      }
+
+      if (hasSyncServerStorageId && !hasSyncServer) {
+        console.error(
+          chalk.red("Error: --sync-server-storage-id requires --sync-server")
+        );
+        console.error(
+          chalk.yellow("Both arguments must be provided together.")
+        );
+        process.exit(1);
+      }
+
+      await init(path, options.syncServer, options.syncServerStorageId);
+    })
+  );
+
+// Clone command
+program
+  .command("clone")
+  .description("Clone an existing synced directory")
+  .argument("<url>", "AutomergeUrl of root directory to clone")
+  .argument("<path>", "Target directory path")
+  .option("--force", "Overwrite existing directory")
+  .option(
+    "--sync-server <url>",
+    "Custom sync server URL (must be used with --sync-server-storage-id)"
+  )
+  .option(
+    "--sync-server-storage-id <id>",
+    "Custom sync server storage ID (must be used with --sync-server)"
+  )
+  .addHelpText(
+    "after",
+    `
+Examples:
+  pushwork clone automerge:abc123 ./my-clone
+  pushwork clone automerge:abc123 ./my-clone --force
+  pushwork clone automerge:abc123 ./my-clone --sync-server ws://localhost:3030 --sync-server-storage-id 1d89eba7-f7a4-4e8e-80f2-5f4e2406f507
+  
+Note: Custom sync server options must always be used together.`
+  )
+  .action(
+    withErrorHandling(async (url: string, path: string, options) => {
+      // Validate that both sync server options are provided together
+      const hasSyncServer = !!options.syncServer;
+      const hasSyncServerStorageId = !!options.syncServerStorageId;
+
+      if (hasSyncServer && !hasSyncServerStorageId) {
+        console.error(
+          chalk.red("Error: --sync-server requires --sync-server-storage-id")
+        );
+        console.error(
+          chalk.yellow("Both arguments must be provided together.")
+        );
+        process.exit(1);
+      }
+
+      if (hasSyncServerStorageId && !hasSyncServer) {
+        console.error(
+          chalk.red("Error: --sync-server-storage-id requires --sync-server")
+        );
+        console.error(
+          chalk.yellow("Both arguments must be provided together.")
+        );
+        process.exit(1);
+      }
+
+      await clone(url, path, {
+        force: options.force || false,
+        dryRun: false,
+        verbose: false,
+        syncServer: options.syncServer,
+        syncServerStorageId: options.syncServerStorageId,
+      });
+    })
+  );
+
+// Commit command
+program
+  .command("commit")
+  .description("Commit local changes (no network sync)")
+  .argument("[path]", "Directory path to commit", ".")
+  .option("--dry-run", "Show what would be committed without applying changes")
+  .action(
+    withErrorHandling(async (path: string, options) => {
+      await commit(path, options.dryRun || false);
+    })
+  );
+
+// Sync command
+program
+  .command("sync")
+  .description("Run full bidirectional synchronization")
+  .option("--dry-run", "Show what would be done without applying changes")
+  .option("-v, --verbose", "Verbose output")
+  .action(
+    withErrorHandling(async (options) => {
+      await sync({
+        dryRun: options.dryRun || false,
+        verbose: options.verbose || false,
+      });
+    })
+  );
+
+// Diff command
+program
+  .command("diff")
+  .description("Show changes in working directory since last sync")
+  .argument("[path]", "Limit diff to specific path", ".")
+  .option("--tool <tool>", "Use external diff tool (meld, vimdiff, etc.)")
+  .option("--name-only", "Show only changed file names")
+  .action(
+    withErrorHandling(async (path: string, options) => {
+      await diff(path, {
+        tool: options.tool,
+        nameOnly: options.nameOnly || false,
+        dryRun: false,
+        verbose: false,
+      });
+    })
+  );
+
+// Status command
+program
+  .command("status")
+  .description("Show sync status summary")
+  .action(
+    withErrorHandling(async (options) => {
+      await status();
+    })
+  );
+
+// Log command
+program
+  .command("log")
+  .description("Show sync history")
+  .argument("[path]", "Show history for specific file or directory", ".")
+  .option("--oneline", "Compact one-line per sync format")
+  .option("--since <date>", "Show syncs since date")
+  .option("--limit <n>", "Limit number of syncs shown", "10")
+  .action(
+    withErrorHandling(async (path: string, options) => {
+      await log(path, {
+        oneline: options.oneline || false,
+        since: options.since,
+        limit: parseInt(options.limit),
+        dryRun: false,
+        verbose: false,
+      });
+    })
+  );
+
+// Checkout command
+program
+  .command("checkout")
+  .description("Restore directory to state from previous sync")
+  .argument("<sync-id>", "Sync ID to restore to")
+  .argument("[path]", "Specific path to restore", ".")
+  .option("-f, --force", "Force checkout even if there are uncommitted changes")
+  .action(
+    withErrorHandling(async (syncId: string, path: string, options) => {
+      await checkout(syncId, path, {
+        force: options.force || false,
+        dryRun: false,
+        verbose: false,
+      });
+    })
+  );
+
+// URL command
+program
+  .command("url")
+  .description("Show the Automerge root URL for this repository")
+  .argument("[path]", "Directory path", ".")
+  .addHelpText(
+    "after",
+    `
+Examples:
+  pushwork url           # Show URL for current directory
+  pushwork url ./repo    # Show URL for specific directory
+  
+Note: This command outputs only the URL, making it useful for scripts.`
+  )
+  .action(
+    withErrorHandling(async (path: string) => {
+      await url(path);
+    })
+  );
+
+// Global error handler
+process.on("unhandledRejection", (reason, promise) => {
+  console.error(
+    chalk.red("Unhandled Rejection at:"),
+    promise,
+    chalk.red("reason:"),
+    reason
+  );
+  process.exit(1);
+});
+
+process.on("uncaughtException", (error) => {
+  console.error(chalk.red("Uncaught Exception:"), error);
+  process.exit(1);
+});
+
+// Parse arguments
+program.parse();
+
+// Show help if no arguments provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/src/config/index.ts

@@ -0,0 +1,334 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import { GlobalConfig, DirectoryConfig } from "../types";
+import { pathExists, ensureDirectoryExists } from "../utils";
+
+/**
+ * Configuration manager for pushwork
+ */
+export class ConfigManager {
+  private static readonly GLOBAL_CONFIG_DIR = ".pushwork";
+  private static readonly CONFIG_FILENAME = "config.json";
+  private static readonly LOCAL_CONFIG_DIR = ".pushwork";
+
+  constructor(private workingDir?: string) {}
+
+  /**
+   * Get global configuration path
+   */
+  private getGlobalConfigPath(): string {
+    return path.join(
+      os.homedir(),
+      ConfigManager.GLOBAL_CONFIG_DIR,
+      ConfigManager.CONFIG_FILENAME
+    );
+  }
+
+  /**
+   * Get local configuration path
+   */
+  private getLocalConfigPath(): string {
+    if (!this.workingDir) {
+      throw new Error("Working directory not set for local config");
+    }
+    return path.join(
+      this.workingDir,
+      ConfigManager.LOCAL_CONFIG_DIR,
+      ConfigManager.CONFIG_FILENAME
+    );
+  }
+
+  /**
+   * Load global configuration
+   */
+  async loadGlobal(): Promise<GlobalConfig | null> {
+    try {
+      const configPath = this.getGlobalConfigPath();
+      if (!(await pathExists(configPath))) {
+        return null;
+      }
+
+      const content = await fs.readFile(configPath, "utf8");
+      return JSON.parse(content) as GlobalConfig;
+    } catch (error) {
+      console.warn(`Failed to load global config: ${error}`);
+      return null;
+    }
+  }
+
+  /**
+   * Save global configuration
+   */
+  async saveGlobal(config: GlobalConfig): Promise<void> {
+    try {
+      const configPath = this.getGlobalConfigPath();
+      await ensureDirectoryExists(path.dirname(configPath));
+
+      const content = JSON.stringify(config, null, 2);
+      await fs.writeFile(configPath, content, "utf8");
+    } catch (error) {
+      throw new Error(`Failed to save global config: ${error}`);
+    }
+  }
+
+  /**
+   * Load local/directory configuration
+   */
+  async load(): Promise<DirectoryConfig | null> {
+    if (!this.workingDir) {
+      return null;
+    }
+
+    try {
+      const configPath = this.getLocalConfigPath();
+      if (!(await pathExists(configPath))) {
+        return null;
+      }
+
+      const content = await fs.readFile(configPath, "utf8");
+      return JSON.parse(content) as DirectoryConfig;
+    } catch (error) {
+      console.warn(`Failed to load local config: ${error}`);
+      return null;
+    }
+  }
+
+  /**
+   * Save local/directory configuration
+   */
+  async save(config: DirectoryConfig): Promise<void> {
+    if (!this.workingDir) {
+      throw new Error("Working directory not set for local config");
+    }
+
+    try {
+      const configPath = this.getLocalConfigPath();
+      await ensureDirectoryExists(path.dirname(configPath));
+
+      const content = JSON.stringify(config, null, 2);
+      await fs.writeFile(configPath, content, "utf8");
+    } catch (error) {
+      throw new Error(`Failed to save local config: ${error}`);
+    }
+  }
+
+  /**
+   * Get merged configuration (global + local)
+   */
+  async getMerged(): Promise<DirectoryConfig> {
+    const globalConfig = await this.loadGlobal();
+    const localConfig = await this.load();
+
+    // Create default configuration
+    const defaultConfig: DirectoryConfig = {
+      sync_enabled: true,
+      sync_server_storage_id: "3760df37-a4c6-4f66-9ecd-732039a9385d",
+      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,
+      },
+    };
+
+    // Merge configurations: default < global < local
+    let merged = { ...defaultConfig };
+
+    if (globalConfig) {
+      merged = this.mergeConfigs(merged, globalConfig);
+    }
+
+    if (localConfig) {
+      merged = this.mergeConfigs(merged, localConfig);
+    }
+
+    return merged;
+  }
+
+  /**
+   * Merge two configuration objects
+   */
+  private mergeConfigs(
+    base: DirectoryConfig,
+    override: Partial<DirectoryConfig> | GlobalConfig
+  ): DirectoryConfig {
+    const merged = { ...base };
+
+    if ("sync_server" in override && override.sync_server !== undefined) {
+      merged.sync_server = override.sync_server;
+    }
+
+    if (
+      "sync_server_storage_id" in override &&
+      override.sync_server_storage_id !== undefined
+    ) {
+      merged.sync_server_storage_id = override.sync_server_storage_id;
+    }
+
+    if ("sync_enabled" in override && override.sync_enabled !== undefined) {
+      merged.sync_enabled = override.sync_enabled;
+    }
+
+    // Handle GlobalConfig structure
+    if ("exclude_patterns" in override && override.exclude_patterns) {
+      merged.defaults.exclude_patterns = override.exclude_patterns;
+    }
+
+    if ("large_file_threshold" in override && override.large_file_threshold) {
+      merged.defaults.large_file_threshold = override.large_file_threshold;
+    }
+
+    // Handle DirectoryConfig structure
+    if ("defaults" in override && override.defaults) {
+      merged.defaults = { ...merged.defaults, ...override.defaults };
+    }
+
+    if ("diff" in override && override.diff) {
+      // Merge diff settings, ensuring show_binary has a default
+      merged.diff = {
+        ...merged.diff,
+        ...override.diff,
+        show_binary: override.diff.show_binary ?? merged.diff.show_binary,
+      };
+    }
+
+    if ("sync" in override && override.sync) {
+      merged.sync = { ...merged.sync, ...override.sync };
+    }
+
+    return merged;
+  }
+
+  /**
+   * Create default global configuration
+   */
+  async createDefaultGlobal(): Promise<void> {
+    const defaultGlobal: GlobalConfig = {
+      exclude_patterns: [
+        ".git",
+        "node_modules",
+        "*.tmp",
+        ".DS_Store",
+        ".pushwork",
+      ],
+      large_file_threshold: "100MB",
+      sync_server: "wss://sync3.automerge.org",
+      sync_server_storage_id: "3760df37-a4c6-4f66-9ecd-732039a9385d",
+      diff: {
+        show_binary: false,
+      },
+      sync: {
+        move_detection_threshold: 0.8,
+        prompt_threshold: 0.5,
+        auto_sync: false,
+        parallel_operations: 4,
+      },
+    };
+
+    await this.saveGlobal(defaultGlobal);
+  }
+
+  /**
+   * Check if global configuration exists
+   */
+  async globalConfigExists(): Promise<boolean> {
+    return await pathExists(this.getGlobalConfigPath());
+  }
+
+  /**
+   * Check if local configuration exists
+   */
+  async localConfigExists(): Promise<boolean> {
+    if (!this.workingDir) return false;
+    return await pathExists(this.getLocalConfigPath());
+  }
+
+  /**
+   * Get configuration value by path (e.g., 'sync.auto_sync')
+   */
+  async getValue(keyPath: string): Promise<any> {
+    const config = await this.getMerged();
+
+    const keys = keyPath.split(".");
+    let value: any = config;
+
+    for (const key of keys) {
+      if (value && typeof value === "object" && key in value) {
+        value = value[key];
+      } else {
+        return undefined;
+      }
+    }
+
+    return value;
+  }
+
+  /**
+   * Set configuration value by path
+   */
+  async setValue(keyPath: string, value: any): Promise<void> {
+    const config = (await this.load()) || ({} as DirectoryConfig);
+
+    const keys = keyPath.split(".");
+    let current: any = config;
+
+    // Navigate to the parent of the target key
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!(key in current) || typeof current[key] !== "object") {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+
+    // Set the value
+    const finalKey = keys[keys.length - 1];
+    current[finalKey] = value;
+
+    await this.save(config);
+  }
+
+  /**
+   * Validate configuration
+   */
+  validate(config: DirectoryConfig): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (config.sync?.move_detection_threshold !== undefined) {
+      if (
+        config.sync.move_detection_threshold < 0 ||
+        config.sync.move_detection_threshold > 1
+      ) {
+        errors.push("move_detection_threshold must be between 0 and 1");
+      }
+    }
+
+    if (config.sync?.prompt_threshold !== undefined) {
+      if (
+        config.sync.prompt_threshold < 0 ||
+        config.sync.prompt_threshold > 1
+      ) {
+        errors.push("prompt_threshold must be between 0 and 1");
+      }
+    }
+
+    if (config.sync?.parallel_operations !== undefined) {
+      if (config.sync.parallel_operations < 1) {
+        errors.push("parallel_operations must be at least 1");
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+    };
+  }
+}