feat: Phase 3 - CLI sync commands

- Created comprehensive sync command suite:
  - 'opal sync init' - Configure sync with server (URL, API key)
  - 'opal sync status' - Show sync configuration and queue status
  - 'opal sync now' - Bidirectional sync with conflict resolution
  - 'opal sync up' - Push local changes to server
  - 'opal sync down' - Pull server changes to local
  - 'opal sync log' - View conflict resolution log
- Added interactive prompts for init (URL and API key)
- Automatic client ID generation (UUID)
- Display user-friendly sync results with emojis
- Support for viewing queued offline changes
- Integration with config system for persistent sync settings

opal-task/cmd/root.go

@@ -25,7 +25,7 @@ const parsedArgsKey contextKey = "parsedArgs"
 var commandNames = []string{
 	"add", "list", "done", "modify", "delete",
 	"start", "stop", "count", "projects", "tags",
-	"info", "edit", "server",
+	"info", "edit", "server", "sync",
 }
 
 var commandsWithModifiers = map[string]bool{

opal-task/cmd/sync.go

@@ -0,0 +1,363 @@
+package cmd
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+
+	"git.jnss.me/joakim/opal/internal/engine"
+	"git.jnss.me/joakim/opal/internal/sync"
+	"github.com/google/uuid"
+	"github.com/spf13/cobra"
+)
+
+var syncCmd = &cobra.Command{
+	Use:   "sync",
+	Short: "Sync tasks with remote server",
+	Long:  `Manage synchronization with the opal API server`,
+}
+
+// opal sync init
+var syncInitCmd = &cobra.Command{
+	Use:   "init",
+	Short: "Configure sync with server",
+	Long: `Initialize sync configuration with the opal server.
+
+This will prompt for server URL and API key, then save the configuration.
+
+Examples:
+  opal sync init
+  opal sync init --url https://opal.example.com --key oak_xxx`,
+	Run: func(cmd *cobra.Command, args []string) {
+		url, _ := cmd.Flags().GetString("url")
+		key, _ := cmd.Flags().GetString("key")
+
+		// Load existing config
+		cfg, err := engine.GetConfig()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error loading config: %v\n", err)
+			os.Exit(1)
+		}
+
+		// Prompt for URL if not provided
+		if url == "" {
+			fmt.Print("Enter server URL: ")
+			reader := bufio.NewReader(os.Stdin)
+			url, _ = reader.ReadString('\n')
+			url = strings.TrimSpace(url)
+		}
+
+		// Prompt for API key if not provided
+		if key == "" {
+			fmt.Print("Enter API key: ")
+			reader := bufio.NewReader(os.Stdin)
+			key, _ = reader.ReadString('\n')
+			key = strings.TrimSpace(key)
+		}
+
+		// Generate client ID if not exists
+		clientID := cfg.SyncClientID
+		if clientID == "" {
+			clientID = uuid.New().String()
+		}
+
+		// Update config
+		cfg.SyncEnabled = true
+		cfg.SyncURL = url
+		cfg.SyncAPIKey = key
+		cfg.SyncClientID = clientID
+		cfg.SyncStrategy = "last-write-wins"
+		cfg.SyncQueueOffline = true
+
+		// Save config
+		if err := engine.SaveConfig(cfg); err != nil {
+			fmt.Fprintf(os.Stderr, "Error saving config: %v\n", err)
+			os.Exit(1)
+		}
+
+		// Test connection
+		client := sync.NewClient(url, key, clientID)
+		fmt.Println("\n✓ Sync configuration saved")
+		fmt.Printf("  URL:       %s\n", url)
+		fmt.Printf("  Client ID: %s\n", clientID)
+		fmt.Printf("  Strategy:  %s\n", cfg.SyncStrategy)
+
+		// Offer to sync now
+		fmt.Print("\nRun initial sync now? [y/N]: ")
+		reader := bufio.NewReader(os.Stdin)
+		response, _ := reader.ReadString('\n')
+		response = strings.TrimSpace(strings.ToLower(response))
+
+		if response == "y" || response == "yes" {
+			strategy := sync.ParseStrategy(cfg.SyncStrategy)
+			result, err := client.Sync(strategy)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error syncing: %v\n", err)
+				os.Exit(1)
+			}
+			result.Display()
+		}
+	},
+}
+
+// opal sync status
+var syncStatusCmd = &cobra.Command{
+	Use:   "status",
+	Short: "Show sync status",
+	Long:  `Display current sync configuration and status`,
+	Run: func(cmd *cobra.Command, args []string) {
+		cfg, err := engine.GetConfig()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error loading config: %v\n", err)
+			os.Exit(1)
+		}
+
+		if !cfg.SyncEnabled {
+			fmt.Println("Sync is not configured.")
+			fmt.Println("Run 'opal sync init' to configure sync.")
+			return
+		}
+
+		fmt.Println("Sync Configuration")
+		fmt.Println("━━━━━━━━━━━━━━━━━━")
+		fmt.Printf("Enabled:        %v\n", cfg.SyncEnabled)
+		fmt.Printf("URL:            %s\n", cfg.SyncURL)
+		fmt.Printf("Client ID:      %s\n", cfg.SyncClientID)
+		fmt.Printf("Strategy:       %s\n", cfg.SyncStrategy)
+		fmt.Printf("Queue offline:  %v\n", cfg.SyncQueueOffline)
+
+		// Check queue status
+		queue, err := sync.NewQueue()
+		if err == nil && queue.Size() > 0 {
+			fmt.Printf("\n⚠️  %d changes queued for sync\n", queue.Size())
+		}
+
+		// Get last sync time
+		db := engine.GetDB()
+		if db != nil {
+			var lastSync int64
+			err := db.QueryRow("SELECT last_sync FROM sync_state WHERE client_id = ?", cfg.SyncClientID).Scan(&lastSync)
+			if err == nil && lastSync > 0 {
+				fmt.Printf("\nLast sync:      %s\n", formatTimestamp(lastSync))
+			}
+		}
+
+		// Test connectivity
+		fmt.Print("\nTesting connection... ")
+		_ = sync.NewClient(cfg.SyncURL, cfg.SyncAPIKey, cfg.SyncClientID)
+		// Simple connectivity test - we can't call testConnection directly, so we'll just show config
+		fmt.Println("(run 'opal sync now' to test)")
+	},
+}
+
+// opal sync now (default)
+var syncNowCmd = &cobra.Command{
+	Use:   "now",
+	Short: "Sync with server now",
+	Long:  `Perform bidirectional sync with the server`,
+	Run: func(cmd *cobra.Command, args []string) {
+		cfg, err := engine.GetConfig()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error loading config: %v\n", err)
+			os.Exit(1)
+		}
+
+		if !cfg.SyncEnabled {
+			fmt.Println("Sync is not configured.")
+			fmt.Println("Run 'opal sync init' to configure sync.")
+			os.Exit(1)
+		}
+
+		client := sync.NewClient(cfg.SyncURL, cfg.SyncAPIKey, cfg.SyncClientID)
+		strategy := sync.ParseStrategy(cfg.SyncStrategy)
+
+		result, err := client.Sync(strategy)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			os.Exit(1)
+		}
+
+		result.Display()
+	},
+}
+
+// opal sync up
+var syncUpCmd = &cobra.Command{
+	Use:   "up",
+	Short: "Push local changes to server",
+	Long:  `Upload local changes to the server`,
+	Run: func(cmd *cobra.Command, args []string) {
+		cfg, err := engine.GetConfig()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error loading config: %v\n", err)
+			os.Exit(1)
+		}
+
+		if !cfg.SyncEnabled {
+			fmt.Println("Sync is not configured.")
+			os.Exit(1)
+		}
+
+		client := sync.NewClient(cfg.SyncURL, cfg.SyncAPIKey, cfg.SyncClientID)
+
+		// Get local changes
+		lastSync := getLastSyncTime(cfg.SyncClientID)
+		localChanges, err := getLocalChanges(lastSync)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error getting local changes: %v\n", err)
+			os.Exit(1)
+		}
+
+		if len(localChanges) == 0 {
+			fmt.Println("No local changes to push")
+			return
+		}
+
+		fmt.Printf("Pushing %d changes...\n", len(localChanges))
+		if err := client.PushChanges(localChanges); err != nil {
+			fmt.Fprintf(os.Stderr, "Error pushing changes: %v\n", err)
+			os.Exit(1)
+		}
+
+		fmt.Println("✓ Changes pushed successfully")
+	},
+}
+
+// opal sync down
+var syncDownCmd = &cobra.Command{
+	Use:   "down",
+	Short: "Pull server changes to local",
+	Long:  `Download changes from the server`,
+	Run: func(cmd *cobra.Command, args []string) {
+		cfg, err := engine.GetConfig()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error loading config: %v\n", err)
+			os.Exit(1)
+		}
+
+		if !cfg.SyncEnabled {
+			fmt.Println("Sync is not configured.")
+			os.Exit(1)
+		}
+
+		client := sync.NewClient(cfg.SyncURL, cfg.SyncAPIKey, cfg.SyncClientID)
+		lastSync := getLastSyncTime(cfg.SyncClientID)
+
+		changes, err := client.PullChanges(lastSync)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error pulling changes: %v\n", err)
+			os.Exit(1)
+		}
+
+		if len(changes) == 0 {
+			fmt.Println("No changes from server")
+			return
+		}
+
+		fmt.Printf("✓ Pulled %d changes from server\n", len(changes))
+	},
+}
+
+// opal sync log
+var syncLogCmd = &cobra.Command{
+	Use:   "log",
+	Short: "Show conflict resolution log",
+	Long:  `Display the log of sync conflicts and how they were resolved`,
+	Run: func(cmd *cobra.Command, args []string) {
+		configDir, err := engine.GetConfigDir()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			os.Exit(1)
+		}
+
+		logPath := fmt.Sprintf("%s/sync_conflicts.log", configDir)
+		data, err := os.ReadFile(logPath)
+		if err != nil {
+			if os.IsNotExist(err) {
+				fmt.Println("No conflicts logged yet.")
+				return
+			}
+			fmt.Fprintf(os.Stderr, "Error reading log: %v\n", err)
+			os.Exit(1)
+		}
+
+		fmt.Print(string(data))
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(syncCmd)
+
+	syncCmd.AddCommand(syncInitCmd)
+	syncCmd.AddCommand(syncStatusCmd)
+	syncCmd.AddCommand(syncNowCmd)
+	syncCmd.AddCommand(syncUpCmd)
+	syncCmd.AddCommand(syncDownCmd)
+	syncCmd.AddCommand(syncLogCmd)
+
+	// Flags
+	syncInitCmd.Flags().StringP("url", "u", "", "Server URL")
+	syncInitCmd.Flags().StringP("key", "k", "", "API key")
+}
+
+// Helper functions
+
+func getLastSyncTime(clientID string) int64 {
+	db := engine.GetDB()
+	if db == nil {
+		return 0
+	}
+
+	var lastSync int64
+	err := db.QueryRow("SELECT last_sync FROM sync_state WHERE client_id = ?", clientID).Scan(&lastSync)
+	if err != nil {
+		return 0
+	}
+
+	return lastSync
+}
+
+func getLocalChanges(since int64) ([]*engine.Task, error) {
+	db := engine.GetDB()
+	if db == nil {
+		return nil, fmt.Errorf("database not initialized")
+	}
+
+	rows, err := db.Query(`
+		SELECT DISTINCT task_uuid
+		FROM change_log
+		WHERE changed_at > ?
+		ORDER BY changed_at ASC
+	`, since)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var tasks []*engine.Task
+	for rows.Next() {
+		var uuidStr string
+		if err := rows.Scan(&uuidStr); err != nil {
+			continue
+		}
+
+		taskUUID, err := uuid.Parse(uuidStr)
+		if err != nil {
+			continue
+		}
+
+		task, err := engine.GetTask(taskUUID)
+		if err != nil {
+			continue
+		}
+
+		tasks = append(tasks, task)
+	}
+
+	return tasks, nil
+}
+
+func formatTimestamp(ts int64) string {
+	return fmt.Sprintf("%d", ts) // Simple for now, can enhance later
+}