diff --git a/cmd/bd/git_sync_test.go b/cmd/bd/git_sync_test.go deleted file mode 100644 index 3230acf9b..000000000 --- a/cmd/bd/git_sync_test.go +++ /dev/null @@ -1,317 +0,0 @@ -//go:build cgo && integration - -package main - -import ( - "bytes" - "context" - "encoding/json" - "os" - "os/exec" - "path/filepath" - "testing" - "time" - - "github.com/steveyegge/beads/internal/storage/dolt" - "github.com/steveyegge/beads/internal/types" -) - -// TestGitPullSyncIntegration tests the full git pull sync scenario -// Verifies that after git pull, both daemon and non-daemon modes pick up changes automatically -func TestGitPullSyncIntegration(t *testing.T) { - if testing.Short() { - t.Skip("Skipping integration test in short mode") - } - - // Create temp directory for test repositories - tempDir := t.TempDir() - - // Create "remote" repository - remoteDir := filepath.Join(tempDir, "remote") - if err := os.MkdirAll(remoteDir, 0750); err != nil { - t.Fatalf("Failed to create remote dir: %v", err) - } - - // Initialize remote git repo - runGitCmd(t, remoteDir, "init", "--bare", "-b", "master") - - // Create "clone1" repository - clone1Dir := filepath.Join(tempDir, "clone1") - runGitCmd(t, tempDir, "clone", remoteDir, clone1Dir) - configureGit(t, clone1Dir) - - // Initialize beads in clone1 - clone1BeadsDir := filepath.Join(clone1Dir, ".beads") - if err := os.MkdirAll(clone1BeadsDir, 0750); err != nil { - t.Fatalf("Failed to create .beads dir: %v", err) - } - - clone1DBPath := filepath.Join(clone1BeadsDir, "test.db") - clone1Store := newTestStore(t, clone1DBPath) - defer clone1Store.Close() - - ctx := context.Background() - if err := clone1Store.SetMetadata(ctx, "issue_prefix", "test"); err != nil { - t.Fatalf("Failed to set prefix: %v", err) - } - - // Create and close an issue in clone1 - issue := &types.Issue{ - Title: "Test sync issue", - Status: types.StatusOpen, - Priority: 1, - IssueType: types.TypeTask, - CreatedAt: time.Now(), - UpdatedAt: time.Now(), - } - if err := clone1Store.CreateIssue(ctx, issue, "test-user"); err != nil { - t.Fatalf("Failed to create issue: %v", err) - } - issueID := issue.ID - - // Close the issue - if err := clone1Store.CloseIssue(ctx, issueID, "Test completed", "test-user", ""); err != nil { - t.Fatalf("Failed to close issue: %v", err) - } - - // Export to JSONL - jsonlPath := filepath.Join(clone1BeadsDir, "issues.jsonl") - if err := exportIssuesToJSONL(ctx, clone1Store, jsonlPath); err != nil { - t.Fatalf("Failed to export: %v", err) - } - - // Commit and push from clone1 - runGitCmd(t, clone1Dir, "add", ".beads") - runGitCmd(t, clone1Dir, "commit", "-m", "Add closed issue") - runGitCmd(t, clone1Dir, "push", "origin", "master") - - // Create "clone2" repository - clone2Dir := filepath.Join(tempDir, "clone2") - runGitCmd(t, tempDir, "clone", remoteDir, clone2Dir) - configureGit(t, clone2Dir) - - // Initialize empty database in clone2 - clone2BeadsDir := filepath.Join(clone2Dir, ".beads") - clone2DBPath := filepath.Join(clone2BeadsDir, "test.db") - clone2Store := newTestStore(t, clone2DBPath) - defer clone2Store.Close() - - if err := clone2Store.SetMetadata(ctx, "issue_prefix", "test"); err != nil { - t.Fatalf("Failed to set prefix: %v", err) - } - - // Import the existing JSONL (simulating initial sync) - clone2JSONLPath := filepath.Join(clone2BeadsDir, "issues.jsonl") - if err := importJSONLToStore(ctx, clone2Store, clone2DBPath, clone2JSONLPath); err != nil { - t.Fatalf("Failed to import: %v", err) - } - - // Verify issue exists and is closed - verifyIssueClosed(t, clone2Store, issueID) - - // Note: We don't commit in clone2 - it stays clean as a read-only consumer - - // Now test git pull scenario: Clone1 makes a change (update priority) - if err := clone1Store.UpdateIssue(ctx, issueID, map[string]interface{}{ - "priority": 0, - }, "test-user"); err != nil { - t.Fatalf("Failed to update issue: %v", err) - } - - if err := exportIssuesToJSONL(ctx, clone1Store, jsonlPath); err != nil { - t.Fatalf("Failed to export after update: %v", err) - } - - runGitCmd(t, clone1Dir, "add", ".beads/issues.jsonl") - runGitCmd(t, clone1Dir, "commit", "-m", "Update priority") - runGitCmd(t, clone1Dir, "push", "origin", "master") - - // Clone2 pulls the change - runGitCmd(t, clone2Dir, "pull") - - // Test auto-import in non-daemon mode - t.Run("NonDaemonAutoImport", func(t *testing.T) { - // Use a temporary local store for this test - localStore := newTestStore(t, clone2DBPath) - defer localStore.Close() - - // Manually import to simulate auto-import behavior - startTime := time.Now() - if err := importJSONLToStore(ctx, localStore, clone2DBPath, clone2JSONLPath); err != nil { - t.Fatalf("Failed to auto-import: %v", err) - } - elapsed := time.Since(startTime) - - // Verify priority was updated - issue, err := localStore.GetIssue(ctx, issueID) - if err != nil { - t.Fatalf("Failed to get issue: %v", err) - } - if issue.Priority != 0 { - t.Errorf("Expected priority 0 after auto-import, got %d", issue.Priority) - } - - // Verify performance: import should be fast - if elapsed > 100*time.Millisecond { - t.Logf("Info: import took %v", elapsed) - } - }) - - // Test bd sync --import-only command - t.Run("BdSyncCommand", func(t *testing.T) { - // Make another change in clone1 (change priority back to 1) - if err := clone1Store.UpdateIssue(ctx, issueID, map[string]interface{}{ - "priority": 1, - }, "test-user"); err != nil { - t.Fatalf("Failed to update issue: %v", err) - } - - if err := exportIssuesToJSONL(ctx, clone1Store, jsonlPath); err != nil { - t.Fatalf("Failed to export: %v", err) - } - - runGitCmd(t, clone1Dir, "add", ".beads/issues.jsonl") - runGitCmd(t, clone1Dir, "commit", "-m", "Update priority") - runGitCmd(t, clone1Dir, "push", "origin", "master") - - // Clone2 pulls - runGitCmd(t, clone2Dir, "pull") - - // Use a fresh store for import - syncStore := newTestStore(t, clone2DBPath) - defer syncStore.Close() - - // Manually trigger import via in-process equivalent - if err := importJSONLToStore(ctx, syncStore, clone2DBPath, clone2JSONLPath); err != nil { - t.Fatalf("Failed to import via sync: %v", err) - } - - // Verify priority was updated back to 1 - issue, err := syncStore.GetIssue(ctx, issueID) - if err != nil { - t.Fatalf("Failed to get issue: %v", err) - } - if issue.Priority != 1 { - t.Errorf("Expected priority 1, got %d", issue.Priority) - } - }) -} - -// Helper functions - -func runGitCmd(t *testing.T, dir string, args ...string) { - cmd := exec.Command("git", args...) - cmd.Dir = dir - cmd.Env = append(os.Environ(), "GIT_COMMITTER_DATE=2024-01-01T00:00:00", "GIT_AUTHOR_DATE=2024-01-01T00:00:00") - output, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("git %v failed in %s: %v\n%s", args, dir, err, output) - } -} - -func configureGit(t *testing.T, dir string) { - runGitCmd(t, dir, "config", "user.email", "test@example.com") - runGitCmd(t, dir, "config", "user.name", "Test User") - runGitCmd(t, dir, "config", "pull.rebase", "false") - - // Create .gitignore to prevent test database files from being tracked - gitignorePath := filepath.Join(dir, ".gitignore") - gitignoreContent := `# Test database files -*.db -*.db-journal -*.db-wal -*.db-shm -` - if err := os.WriteFile(gitignorePath, []byte(gitignoreContent), 0644); err != nil { - t.Fatalf("Failed to create .gitignore: %v", err) - } -} - -func exportIssuesToJSONL(ctx context.Context, store *dolt.DoltStore, jsonlPath string) error { - issues, err := store.SearchIssues(ctx, "", types.IssueFilter{}) - if err != nil { - return err - } - - // Populate dependencies - allDeps, err := store.GetAllDependencyRecords(ctx) - if err != nil { - return err - } - for _, issue := range issues { - issue.Dependencies = allDeps[issue.ID] - labels, _ := store.GetLabels(ctx, issue.ID) - issue.Labels = labels - } - - f, err := os.Create(jsonlPath) - if err != nil { - return err - } - defer f.Close() - - encoder := json.NewEncoder(f) - for _, issue := range issues { - if err := encoder.Encode(issue); err != nil { - return err - } - } - - return nil -} - -func importJSONLToStore(ctx context.Context, store *dolt.DoltStore, dbPath, jsonlPath string) error { - data, err := os.ReadFile(jsonlPath) - if err != nil { - return err - } - - // Use the autoimport package's AutoImportIfNewer function - // For testing, we'll directly parse and import - var issues []*types.Issue - decoder := json.NewDecoder(bytes.NewReader(data)) - for decoder.More() { - var issue types.Issue - if err := decoder.Decode(&issue); err != nil { - return err - } - issues = append(issues, &issue) - } - - // Import each issue - for _, issue := range issues { - existing, _ := store.GetIssue(ctx, issue.ID) - if existing != nil { - // Update - updates := map[string]interface{}{ - "status": issue.Status, - "priority": issue.Priority, - } - if err := store.UpdateIssue(ctx, issue.ID, updates, "import"); err != nil { - return err - } - } else { - // Create - if err := store.CreateIssue(ctx, issue, "import"); err != nil { - return err - } - } - } - - // Set last_import_time metadata so staleness check works - if err := store.SetMetadata(ctx, "last_import_time", time.Now().Format(time.RFC3339)); err != nil { - return err - } - - return nil -} - -func verifyIssueClosed(t *testing.T, store *dolt.DoltStore, issueID string) { - issue, err := store.GetIssue(context.Background(), issueID) - if err != nil { - t.Fatalf("Failed to get issue %s: %v", issueID, err) - } - if issue.Status != types.StatusClosed { - t.Errorf("Expected issue %s to be closed, got status %s", issueID, issue.Status) - } -} diff --git a/cmd/bd/gitlab_sync_test.go b/cmd/bd/gitlab_sync_test.go deleted file mode 100644 index d2d73e44f..000000000 --- a/cmd/bd/gitlab_sync_test.go +++ /dev/null @@ -1,164 +0,0 @@ -// Package main provides the bd CLI commands. -package main - -import ( - "strings" - "testing" -) - -// TestGenerateUniqueIssueIDs verifies IDs are unique even when generated rapidly. -func TestGenerateUniqueIssueIDs(t *testing.T) { - seen := make(map[string]bool) - prefix := "bd" - - // Generate 100 IDs rapidly - for i := 0; i < 100; i++ { - id := generateIssueID(prefix) - if seen[id] { - t.Errorf("Duplicate ID generated: %s", id) - } - seen[id] = true - } -} - -// TestGenerateIssueIDHasRandomComponent verifies IDs include random bytes for restart safety. -// Without random bytes, counter reset on restart could cause ID collisions. -func TestGenerateIssueIDHasRandomComponent(t *testing.T) { - // Save current counter - oldCounter := issueIDCounter - defer func() { issueIDCounter = oldCounter }() - - prefix := "test" - - // Generate ID, reset counter (simulating restart), generate another - // Both generated at same counter value - should still be unique due to random component - issueIDCounter = 100 - id1 := generateIssueID(prefix) - - // Simulate restart by resetting counter to same value - issueIDCounter = 100 - id2 := generateIssueID(prefix) - - // Even with same counter, IDs should differ due to random component - if id1 == id2 { - t.Errorf("IDs should be unique even with counter reset: id1=%s, id2=%s", id1, id2) - } - - // Verify format includes hex suffix (random bytes) - // Expected format: prefix-timestamp-counter-hex - parts := strings.Split(id1, "-") - if len(parts) != 4 { - t.Errorf("Expected 4 parts (prefix-timestamp-counter-random), got %d: %s", len(parts), id1) - } -} - -// TestGetConflictStrategy verifies conflict strategy selection from flags. -func TestGetConflictStrategy(t *testing.T) { - tests := []struct { - name string - preferLocal bool - preferGitLab bool - preferNewer bool - wantStrategy ConflictStrategy - wantError bool - }{ - { - name: "no flags - default to prefer-newer", - wantStrategy: ConflictStrategyPreferNewer, - }, - { - name: "prefer-local", - preferLocal: true, - wantStrategy: ConflictStrategyPreferLocal, - }, - { - name: "prefer-gitlab", - preferGitLab: true, - wantStrategy: ConflictStrategyPreferGitLab, - }, - { - name: "prefer-newer explicit", - preferNewer: true, - wantStrategy: ConflictStrategyPreferNewer, - }, - { - name: "multiple flags - error", - preferLocal: true, - preferGitLab: true, - wantError: true, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - strategy, err := getConflictStrategy(tt.preferLocal, tt.preferGitLab, tt.preferNewer) - if tt.wantError { - if err == nil { - t.Error("expected error for multiple flags, got nil") - } - return - } - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - if strategy != tt.wantStrategy { - t.Errorf("strategy = %q, want %q", strategy, tt.wantStrategy) - } - }) - } -} - -// TestParseGitLabSourceSystem verifies parsing source system string. -func TestParseGitLabSourceSystem(t *testing.T) { - tests := []struct { - name string - sourceSystem string - wantProjectID int - wantIID int - wantOK bool - }{ - { - name: "valid gitlab source", - sourceSystem: "gitlab:123:42", - wantProjectID: 123, - wantIID: 42, - wantOK: true, - }, - { - name: "different project", - sourceSystem: "gitlab:456:99", - wantProjectID: 456, - wantIID: 99, - wantOK: true, - }, - { - name: "non-gitlab source", - sourceSystem: "linear:ABC-123", - wantProjectID: 0, - wantIID: 0, - wantOK: false, - }, - { - name: "empty source", - sourceSystem: "", - wantProjectID: 0, - wantIID: 0, - wantOK: false, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - projectID, iid, ok := parseGitLabSourceSystem(tt.sourceSystem) - if ok != tt.wantOK { - t.Errorf("parseGitLabSourceSystem(%q) ok = %v, want %v", tt.sourceSystem, ok, tt.wantOK) - } - if projectID != tt.wantProjectID { - t.Errorf("parseGitLabSourceSystem(%q) projectID = %d, want %d", tt.sourceSystem, projectID, tt.wantProjectID) - } - if iid != tt.wantIID { - t.Errorf("parseGitLabSourceSystem(%q) iid = %d, want %d", tt.sourceSystem, iid, tt.wantIID) - } - }) - } -} diff --git a/cmd/bd/migrate_dolt.go b/cmd/bd/migrate_dolt.go index 3c7e7c001..1bd203a8e 100644 --- a/cmd/bd/migrate_dolt.go +++ b/cmd/bd/migrate_dolt.go @@ -134,10 +134,8 @@ func handleToDoltMigration(dryRun bool, autoYes bool) { exitWithError("import_failed", importErr.Error(), "partial Dolt directory has been cleaned up") } - // Set sync.mode to dolt-native in the DB so ShouldExportJSONL skips - // the expensive JSONL export. Without this, the migrated DB has no - // sync.mode set, defaulting to git-portable (10-25s export tax per write). - if err := doltStore.SetConfig(ctx, SyncModeConfigKey, SyncModeDoltNative); err != nil { + // Set sync.mode to dolt-native in the DB. + if err := doltStore.SetConfig(ctx, "sync.mode", "dolt-native"); err != nil { printWarning(fmt.Sprintf("failed to set sync.mode in DB: %v", err)) } else { printSuccess("Set sync.mode = dolt-native in database") diff --git a/cmd/bd/migrate_sync.go b/cmd/bd/migrate_sync.go deleted file mode 100644 index 3d0d2acd2..000000000 --- a/cmd/bd/migrate_sync.go +++ /dev/null @@ -1,540 +0,0 @@ -package main - -import ( - "context" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" - - "github.com/spf13/cobra" - "github.com/steveyegge/beads/internal/beads" - "github.com/steveyegge/beads/internal/git" - "github.com/steveyegge/beads/internal/syncbranch" -) - -var migrateSyncCmd = &cobra.Command{ - Use: "sync ", - Short: "Migrate to sync.branch workflow for multi-clone setups", - Long: `Migrate to using a dedicated sync branch for beads data. - -This command configures the repository to commit .beads changes to a separate -branch (e.g., "beads-sync") instead of the current working branch. This is -essential for multi-clone setups where multiple clones work independently -but need to sync beads data. - -The command will: - 1. Validate the current state (not already configured, not on sync branch) - 2. Create the sync branch if it doesn't exist (from remote or locally) - 3. Set up the git worktree for the sync branch - 4. Set the sync.branch configuration - -After migration, 'bd sync' will commit beads changes to the sync branch via -a git worktree, keeping your working branch clean of beads commits. - -Examples: - # Basic migration to beads-sync branch - bd migrate-sync beads-sync - - # Preview what would happen without making changes - bd migrate-sync beads-sync --dry-run - - # Force migration even if already configured - bd migrate-sync beads-sync --force`, - Args: cobra.ExactArgs(1), - Run: func(cmd *cobra.Command, args []string) { - ctx := rootCtx - branchName := args[0] - dryRun, _ := cmd.Flags().GetBool("dry-run") - force, _ := cmd.Flags().GetBool("force") - orphan, _ := cmd.Flags().GetBool("orphan") - - if err := runMigrateSync(ctx, branchName, dryRun, force, orphan); err != nil { - fmt.Fprintf(os.Stderr, "Error: %v\n", err) - os.Exit(1) - } - }, -} - -func init() { - migrateSyncCmd.Flags().Bool("dry-run", false, "Preview migration without making changes") - migrateSyncCmd.Flags().Bool("force", false, "Force migration even if already configured") - migrateSyncCmd.Flags().Bool("orphan", false, "Migrate existing sync branch to orphan (deletes and recreates)") - migrateCmd.AddCommand(migrateSyncCmd) - - // Backwards compatibility alias at root level (hidden) - migrateSyncAliasCmd := *migrateSyncCmd - migrateSyncAliasCmd.Use = "migrate-sync" - migrateSyncAliasCmd.Hidden = true - migrateSyncAliasCmd.Deprecated = "use 'bd migrate sync' instead (will be removed in v1.0.0)" - rootCmd.AddCommand(&migrateSyncAliasCmd) -} - -func runMigrateSync(ctx context.Context, branchName string, dryRun, force, orphan bool) error { - // Validate branch name - if err := syncbranch.ValidateBranchName(branchName); err != nil { - return fmt.Errorf("invalid branch name: %w", err) - } - - // Check if we're in a git repository - if !isGitRepo() { - return fmt.Errorf("not in a git repository") - } - - // Get RepoContext for git operations - rc, err := beads.GetRepoContext() - if err != nil { - return fmt.Errorf("failed to get repository context: %w", err) - } - - // Ensure store is initialized for config operations - if err := ensureDirectMode("migrate-sync requires direct database access"); err != nil { - return err - } - - // Get current branch - currentBranch, err := getCurrentBranch(ctx) - if err != nil { - return fmt.Errorf("failed to get current branch: %w", err) - } - - // Check if already on the sync branch - if currentBranch == branchName { - return fmt.Errorf("currently on branch '%s' - switch to your main working branch first (e.g., 'git checkout main')", branchName) - } - - // Check if sync.branch is already configured - existingSyncBranch, err := syncbranch.Get(ctx, store) - if err != nil { - return fmt.Errorf("failed to check existing config: %w", err) - } - - if existingSyncBranch != "" && !force { - if existingSyncBranch == branchName { - fmt.Printf("✓ Already configured to use sync branch '%s'\n", branchName) - fmt.Println(" Use --force to reconfigure anyway") - return nil - } - return fmt.Errorf("sync.branch already configured as '%s' (use --force to change to '%s')", existingSyncBranch, branchName) - } - - // Check if we have a remote - hasRemote := hasGitRemote(ctx) - if !hasRemote { - fmt.Println("⚠ Warning: No git remote configured. Sync branch will only exist locally.") - } - - // Get repo root (rc already initialized above) - repoRoot := rc.RepoRoot - - // Find JSONL path - jsonlPath := findJSONLPath() - if jsonlPath == "" { - return fmt.Errorf("not in a bd workspace (no .beads directory found)") - } - - // Check if sync branch exists (locally or remotely) - branchExistsLocally := branchExistsLocal(ctx, branchName) - branchExistsRemotely := branchExistsRemote(ctx, branchName) - - if dryRun { - fmt.Println("=== DRY RUN - No changes will be made ===") - fmt.Println() - fmt.Printf("Current branch: %s\n", currentBranch) - fmt.Printf("Sync branch: %s\n", branchName) - fmt.Printf("Repository root: %s\n", repoRoot) - fmt.Printf("JSONL path: %s\n", jsonlPath) - fmt.Println() - - if existingSyncBranch != "" { - fmt.Printf("→ Would change sync.branch from '%s' to '%s'\n", existingSyncBranch, branchName) - } else { - fmt.Printf("→ Would set sync.branch to '%s'\n", branchName) - } - - if branchExistsLocally { - if orphan { - fmt.Printf("→ Would migrate existing branch '%s' to orphan (delete and recreate)\n", branchName) - } else { - fmt.Printf("→ Branch '%s' exists locally (will use as-is)\n", branchName) - } - } else if branchExistsRemotely { - if orphan { - fmt.Printf("→ Would create new orphan branch '%s' (ignoring remote non-orphan)\n", branchName) - } else { - fmt.Printf("→ Would create local branch '%s' from remote\n", branchName) - } - } else { - fmt.Printf("→ Would create new orphan branch '%s' (no shared history)\n", branchName) - } - - // Use git-common-dir for worktree path to support bare repos and worktrees (GH#639) - gitCommonDir, err := git.GetGitCommonDir() - if err != nil { - return fmt.Errorf("not a git repository: %w", err) - } - worktreePath := filepath.Join(gitCommonDir, "beads-worktrees", branchName) - fmt.Printf("→ Would create worktree at: %s\n", worktreePath) - - fmt.Println("\n=== END DRY RUN ===") - return nil - } - - // Track preserved JSONL for orphan migration (set in migration block, used in sync) - var preservedJSONLPath string - var backupJSONLPath string // Backup file, deleted only on success - - // Step 1: Create or migrate the sync branch - fmt.Printf("→ Setting up sync branch '%s'...\n", branchName) - - // Helper function to create orphan branch using commit-tree (doesn't change HEAD) - createOrphanBranch := func() error { - fmt.Printf(" Creating orphan branch '%s' (no shared history)...\n", branchName) - - // Create an empty tree object using --stdin for cross-platform compatibility - // (avoids /dev/null which doesn't exist on Windows) - emptyTreeCmd := rc.GitCmd(ctx, "hash-object", "-t", "tree", "--stdin") - emptyTreeCmd.Stdin = strings.NewReader("") - emptyTreeOutput, err := emptyTreeCmd.Output() - if err != nil { - return fmt.Errorf("failed to create empty tree: %w", err) - } - emptyTree := strings.TrimSpace(string(emptyTreeOutput)) - - // Create an orphan commit (no parents) with the empty tree - commitTreeCmd := rc.GitCmd(ctx, "commit-tree", emptyTree, "-m", "Initialize beads sync branch") - commitOutput, err := commitTreeCmd.Output() - if err != nil { - return fmt.Errorf("failed to create orphan commit: %w", err) - } - orphanCommit := strings.TrimSpace(string(commitOutput)) - - // Create branch pointing to the orphan commit - branchCmd := rc.GitCmd(ctx, "branch", branchName, orphanCommit) - if output, err := branchCmd.CombinedOutput(); err != nil { - return fmt.Errorf("failed to create branch: %w\n%s", err, output) - } - - return nil - } - - if !branchExistsLocally && !branchExistsRemotely { - // New branch: create as orphan (default behavior) - if err := createOrphanBranch(); err != nil { - return err - } - } else if branchExistsLocally && orphan { - // Migration: delete existing local branch and recreate as orphan - // Safety check: warn if branch has unpushed commits - if !force { - hasUnpushed, err := branchHasUnpushedCommits(ctx, rc, branchName) - if err != nil { - // If we can't check (no remote tracking), warn but continue - fmt.Printf(" Warning: Could not check for unpushed commits: %v\n", err) - } else if hasUnpushed { - return fmt.Errorf("branch '%s' has unpushed commits that would be lost.\n"+ - " Run 'bd sync' first to export database to JSONL and push, or\n"+ - " Use --force to proceed anyway (unpushed commits will be lost)", branchName) - } - } - fmt.Printf(" Migrating existing branch '%s' to orphan...\n", branchName) - - // Check if branch is used by a worktree and preserve JSONL before removing - gitCommonDir, err := git.GetGitCommonDir() - if err != nil { - return fmt.Errorf("not a git repository: %w", err) - } - existingWorktreePath := filepath.Join(gitCommonDir, "beads-worktrees", branchName) - - // Create backup of JSONL before any destructive operations - worktreeJSONL := filepath.Join(existingWorktreePath, ".beads", "issues.jsonl") - if _, err := os.Stat(worktreeJSONL); err == nil { - // Create backup file (kept until migration succeeds) - backupFile, err := os.CreateTemp("", "beads-backup-*.jsonl") - if err != nil { - return fmt.Errorf("failed to create backup file: %w", err) - } - _ = backupFile.Close() // Close before writing content - backupJSONLPath = backupFile.Name() - - // Copy JSONL to backup - input, err := os.ReadFile(worktreeJSONL) // #nosec G304 - path constructed from git worktree - if err != nil { - return fmt.Errorf("failed to read JSONL for backup: %w", err) - } - // nolint:gosec // G306: JSONL needs 0644 for other tools to read - if err := os.WriteFile(backupJSONLPath, input, 0644); err != nil { - return fmt.Errorf("failed to create backup: %w", err) - } - fmt.Printf(" Backed up JSONL (%d bytes) to %s\n", len(input), backupJSONLPath) - - // Also set as preserved path for restoration - preservedJSONLPath = backupJSONLPath - } - - if _, err := os.Stat(existingWorktreePath); err == nil { - fmt.Printf(" Removing existing worktree at %s...\n", existingWorktreePath) - removeCmd := rc.GitCmd(ctx, "worktree", "remove", "--force", existingWorktreePath) - if output, err := removeCmd.CombinedOutput(); err != nil { - return fmt.Errorf("failed to remove existing worktree: %w\n%s", err, output) - } - } - - fmt.Printf(" Deleting existing local branch...\n") - deleteCmd := rc.GitCmd(ctx, "branch", "-D", branchName) - if output, err := deleteCmd.CombinedOutput(); err != nil { - return fmt.Errorf("failed to delete existing branch: %w\n%s", err, output) - } - if err := createOrphanBranch(); err != nil { - return err - } - } else if !branchExistsLocally && branchExistsRemotely && orphan { - // Remote exists but user wants orphan: create local orphan (ignore remote) - fmt.Printf(" Creating local orphan branch (ignoring remote non-orphan)...\n") - if err := createOrphanBranch(); err != nil { - return err - } - } else if !branchExistsLocally && branchExistsRemotely { - // Fetch and create local tracking branch (preserve existing remote) - fmt.Printf(" Fetching remote branch '%s'...\n", branchName) - fetchCmd := rc.GitCmd(ctx, "fetch", "origin", branchName) - if output, err := fetchCmd.CombinedOutput(); err != nil { - return fmt.Errorf("failed to fetch remote branch: %w\n%s", err, output) - } - - // Create local branch tracking remote - createCmd := rc.GitCmd(ctx, "branch", branchName, "origin/"+branchName) - if output, err := createCmd.CombinedOutput(); err != nil { - return fmt.Errorf("failed to create local tracking branch: %w\n%s", err, output) - } - } else { - // Branch exists locally, no --orphan flag: use as-is - fmt.Printf(" Branch '%s' already exists locally (using as-is)\n", branchName) - } - - // Step 2: Create the worktree - // Use git-common-dir for worktree path to support bare repos and worktrees (GH#639) - gitCommonDir, err := git.GetGitCommonDir() - if err != nil { - return fmt.Errorf("not a git repository: %w", err) - } - worktreePath := filepath.Join(gitCommonDir, "beads-worktrees", branchName) - fmt.Printf("→ Creating worktree at %s...\n", worktreePath) - - wtMgr := git.NewWorktreeManager(repoRoot) - if err := wtMgr.CreateBeadsWorktree(branchName, worktreePath); err != nil { - return fmt.Errorf("failed to create worktree: %w", err) - } - - // Step 3: Sync current JSONL to worktree - fmt.Println("→ Syncing current beads data to worktree...") - - jsonlRelPath, err := filepath.Rel(repoRoot, jsonlPath) - if err != nil { - return fmt.Errorf("failed to get relative JSONL path: %w", err) - } - - // If we preserved JSONL during orphan migration, restore it directly - destPath := filepath.Join(worktreePath, ".beads", "issues.jsonl") - if preservedJSONLPath != "" { - if err := os.MkdirAll(filepath.Dir(destPath), 0755); err != nil { - return fmt.Errorf("failed to create .beads directory: %w", err) - } - input, err := os.ReadFile(preservedJSONLPath) // #nosec G304 - path from backup temp file - if err != nil { - return fmt.Errorf("failed to read preserved JSONL: %w", err) - } - // nolint:gosec // G306: JSONL needs 0644 for other tools to read - if err := os.WriteFile(destPath, input, 0644); err != nil { - return fmt.Errorf("failed to restore JSONL to worktree: %w", err) - } - fmt.Printf(" Restored JSONL (%d bytes) to worktree\n", len(input)) - // Note: backup cleanup happens at end of successful migration - } else { - // Try normal sync first, fall back to main .beads/ if it fails - syncErr := wtMgr.SyncJSONLToWorktree(worktreePath, jsonlRelPath) - if syncErr != nil { - // Fallback: try copying from main .beads/ directory - mainJSONL := filepath.Join(repoRoot, ".beads", "issues.jsonl") - if _, err := os.Stat(mainJSONL); err == nil { - fmt.Printf(" Falling back to main .beads/issues.jsonl...\n") - if err := os.MkdirAll(filepath.Dir(destPath), 0755); err != nil { - return fmt.Errorf("failed to create .beads directory: %w", err) - } - input, err := os.ReadFile(mainJSONL) // #nosec G304 - path constructed from repoRoot - if err != nil { - return fmt.Errorf("failed to read main JSONL: %w", err) - } - // nolint:gosec // G306: JSONL needs 0644 for other tools to read - if err := os.WriteFile(destPath, input, 0644); err != nil { - return fmt.Errorf("failed to copy JSONL to worktree: %w", err) - } - fmt.Printf(" Copied JSONL (%d bytes) from main .beads/\n", len(input)) - } else { - return fmt.Errorf("failed to sync JSONL to worktree: %w", syncErr) - } - } - } - - // Also sync other beads files - beadsDir := filepath.Dir(jsonlPath) - for _, filename := range []string{"deletions.jsonl", "metadata.json"} { - srcPath := filepath.Join(beadsDir, filename) - if _, err := os.Stat(srcPath); err == nil { - relPath, err := filepath.Rel(repoRoot, srcPath) - if err == nil { - _ = wtMgr.SyncJSONLToWorktree(worktreePath, relPath) - } - } - } - - // Step 4: Commit initial state to sync branch if there are changes - fmt.Println("→ Committing initial state to sync branch...") - - worktreeJSONLPath := filepath.Join(worktreePath, jsonlRelPath) - hasChanges, err := hasChangesInWorktreeDir(ctx, worktreePath) - if err != nil { - fmt.Printf(" Warning: failed to check for changes: %v\n", err) - } - - if hasChanges { - if err := commitInitialSyncState(ctx, worktreePath, jsonlRelPath); err != nil { - fmt.Printf(" Warning: failed to commit initial state: %v\n", err) - } else { - fmt.Println(" Initial state committed to sync branch") - } - } else { - // Check if .beads directory exists in worktree but no changes - worktreeBeadsDir := filepath.Join(worktreePath, ".beads") - if _, err := os.Stat(worktreeBeadsDir); os.IsNotExist(err) { - // .beads doesn't exist in worktree - this is a fresh setup - fmt.Println(" No existing beads data in sync branch") - } else { - fmt.Println(" Sync branch already has current beads data") - } - } - _ = worktreeJSONLPath // silence unused warning - - // Step 5: Set sync.branch config - fmt.Printf("→ Setting sync.branch to '%s'...\n", branchName) - - if err := syncbranch.Set(ctx, store, branchName); err != nil { - return fmt.Errorf("failed to set sync.branch config: %w", err) - } - - // Step 6: Push sync branch to remote if we have one - if hasRemote { - fmt.Printf("→ Pushing sync branch '%s' to remote...\n", branchName) - pushCmd := exec.CommandContext(ctx, "git", "-C", worktreePath, "push", "--set-upstream", "origin", branchName) - output, err := pushCmd.CombinedOutput() - if err != nil { - // Non-fatal - branch might already be up to date or push might fail for other reasons - if !strings.Contains(string(output), "Everything up-to-date") { - fmt.Printf(" Warning: failed to push sync branch: %v\n", err) - fmt.Printf(" You may need to push manually: git push -u origin %s\n", branchName) - } - } else { - fmt.Printf(" Pushed '%s' to origin\n", branchName) - } - } - - fmt.Println() - // Clean up backup file on success (best-effort, ignore errors) - if backupJSONLPath != "" { - _ = os.Remove(backupJSONLPath) - } - - fmt.Println("✓ Migration complete!") - fmt.Println() - fmt.Printf(" sync.branch: %s\n", branchName) - fmt.Printf(" worktree: %s\n", worktreePath) - fmt.Println() - fmt.Println("Next steps:") - fmt.Println(" • 'bd sync' will now commit beads changes to the sync branch") - fmt.Println(" • Your working branch stays clean of beads commits") - fmt.Println(" • Other clones should also run 'bd migrate-sync " + branchName + "'") - - return nil -} - -// branchExistsLocal checks if a branch exists locally -func branchExistsLocal(ctx context.Context, branch string) bool { - rc, err := beads.GetRepoContext() - if err != nil { - return false - } - cmd := rc.GitCmd(ctx, "show-ref", "--verify", "--quiet", "refs/heads/"+branch) - return cmd.Run() == nil -} - -// branchExistsRemote checks if a branch exists on origin remote -func branchExistsRemote(ctx context.Context, branch string) bool { - rc, err := beads.GetRepoContext() - if err != nil { - return false - } - // First fetch to ensure we have latest remote refs - fetchCmd := rc.GitCmd(ctx, "fetch", "origin", "--prune") - _ = fetchCmd.Run() // Best effort - - cmd := rc.GitCmd(ctx, "show-ref", "--verify", "--quiet", "refs/remotes/origin/"+branch) - return cmd.Run() == nil -} - -// branchHasUnpushedCommits checks if a local branch has commits not pushed to remote -func branchHasUnpushedCommits(ctx context.Context, rc *beads.RepoContext, branch string) (bool, error) { - // Check if remote tracking branch exists - remoteRef := "refs/remotes/origin/" + branch - checkCmd := rc.GitCmd(ctx, "show-ref", "--verify", "--quiet", remoteRef) - if err := checkCmd.Run(); err != nil { - // No remote tracking branch - can't determine if unpushed - return false, fmt.Errorf("no remote tracking branch for '%s'", branch) - } - - // Count commits ahead of remote - // git rev-list --count origin/branch..branch - countCmd := rc.GitCmd(ctx, "rev-list", "--count", "origin/"+branch+".."+branch) - output, err := countCmd.Output() - if err != nil { - return false, fmt.Errorf("failed to count commits: %w", err) - } - - count := strings.TrimSpace(string(output)) - return count != "0", nil -} - -// hasChangesInWorktreeDir checks if there are any uncommitted changes in the worktree -func hasChangesInWorktreeDir(ctx context.Context, worktreePath string) (bool, error) { - cmd := exec.CommandContext(ctx, "git", "-C", worktreePath, "status", "--porcelain") - output, err := cmd.Output() - if err != nil { - return false, fmt.Errorf("git status failed: %w", err) - } - return len(strings.TrimSpace(string(output))) > 0, nil -} - -// commitInitialSyncState commits the initial beads state to the sync branch -func commitInitialSyncState(ctx context.Context, worktreePath, jsonlRelPath string) error { - beadsRelDir := filepath.Dir(jsonlRelPath) - - // Stage all beads files - // Use --sparse to work correctly with sparse-checkout enabled worktrees (fixes #1076) - addCmd := exec.CommandContext(ctx, "git", "-C", worktreePath, "add", "--sparse", beadsRelDir) - if err := addCmd.Run(); err != nil { - return fmt.Errorf("git add failed: %w", err) - } - - // Commit - commitCmd := exec.CommandContext(ctx, "git", "-C", worktreePath, "commit", "--no-verify", "-m", "bd migrate-sync: initial sync branch setup") - output, err := commitCmd.CombinedOutput() - if err != nil { - // Check if there's nothing to commit - if strings.Contains(string(output), "nothing to commit") { - return nil - } - return fmt.Errorf("git commit failed: %w\n%s", err, output) - } - - return nil -} diff --git a/cmd/bd/migrate_sync_test.go b/cmd/bd/migrate_sync_test.go deleted file mode 100644 index e27a7da8d..000000000 --- a/cmd/bd/migrate_sync_test.go +++ /dev/null @@ -1,622 +0,0 @@ -package main - -import ( - "context" - "os" - "os/exec" - "path/filepath" - "strings" - "testing" - - "github.com/steveyegge/beads/internal/beads" - "github.com/steveyegge/beads/internal/git" -) - -func TestMigrateSyncValidation(t *testing.T) { - // Test invalid branch names - tests := []struct { - name string - branch string - wantErr bool - }{ - {"valid simple", "beads-sync", false}, - {"valid with slash", "beads/sync", false}, - {"valid with dots", "beads.sync", false}, - {"invalid empty", "", true}, - {"invalid HEAD", "HEAD", true}, - {"invalid dots", "..", true}, - {"invalid leading slash", "/beads", true}, - {"invalid trailing slash", "beads/", true}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // We can't easily test the full command without a git repo, - // but we can test branch validation indirectly - if tt.branch == "" { - // Empty branch should fail at args validation level - return - } - }) - } -} - -func TestMigrateSyncDryRun(t *testing.T) { - // Create a temp directory with a git repo - tmpDir, err := os.MkdirTemp("", "bd-migrate-sync-test") - if err != nil { - t.Fatalf("failed to create temp dir: %v", err) - } - defer os.RemoveAll(tmpDir) - - // Copy cached git template (bd-ktng optimization) - initGitTemplate() - if gitTemplateErr != nil { - t.Fatalf("git template init failed: %v", gitTemplateErr) - } - if err := copyGitDir(gitTemplateDir, tmpDir); err != nil { - t.Fatalf("failed to copy git template: %v", err) - } - - // Create initial commit - testFile := filepath.Join(tmpDir, "test.txt") - if err := os.WriteFile(testFile, []byte("test"), 0644); err != nil { - t.Fatalf("failed to create test file: %v", err) - } - cmd := exec.Command("git", "add", ".") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to git add: %v", err) - } - cmd = exec.Command("git", "commit", "-m", "initial") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to git commit: %v", err) - } - - // Create .beads directory and initialize - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0750); err != nil { - t.Fatalf("failed to create .beads dir: %v", err) - } - - // Create minimal issues.jsonl - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - if err := os.WriteFile(jsonlPath, []byte(""), 0644); err != nil { - t.Fatalf("failed to create issues.jsonl: %v", err) - } - - // Test that branchExistsLocal returns false for non-existent branch - // Note: We need to run this from tmpDir context since branchExistsLocal uses git in cwd - ctx := context.Background() - t.Chdir(tmpDir) - // Reset caches so RepoContext picks up new CWD - beads.ResetCaches() - git.ResetCaches() - defer func() { - beads.ResetCaches() - git.ResetCaches() - }() - - if branchExistsLocal(ctx, "beads-sync") { - t.Error("branchExistsLocal should return false for non-existent branch") - } - - // Create the branch - cmd = exec.Command("git", "branch", "beads-sync") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to create branch: %v", err) - } - - // Now it should exist - if !branchExistsLocal(ctx, "beads-sync") { - t.Error("branchExistsLocal should return true for existing branch") - } -} - -func TestMigrateSyncOrphan(t *testing.T) { - // Create a temp directory with a git repo - tmpDir, err := os.MkdirTemp("", "bd-migrate-sync-orphan-test") - if err != nil { - t.Fatalf("failed to create temp dir: %v", err) - } - defer os.RemoveAll(tmpDir) - - // Copy cached git template (bd-ktng optimization) - initGitTemplate() - if gitTemplateErr != nil { - t.Fatalf("git template init failed: %v", gitTemplateErr) - } - if err := copyGitDir(gitTemplateDir, tmpDir); err != nil { - t.Fatalf("failed to copy git template: %v", err) - } - - // Create initial commit on main branch - testFile := filepath.Join(tmpDir, "test.txt") - if err := os.WriteFile(testFile, []byte("test content"), 0644); err != nil { - t.Fatalf("failed to create test file: %v", err) - } - cmd := exec.Command("git", "add", ".") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to git add: %v", err) - } - cmd = exec.Command("git", "commit", "-m", "initial commit") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to git commit: %v", err) - } - - // Get current branch name (could be main or master) - cmd = exec.Command("git", "branch", "--show-current") - cmd.Dir = tmpDir - output, err := cmd.Output() - if err != nil { - t.Fatalf("failed to get current branch: %v", err) - } - mainBranch := strings.TrimSpace(string(output)) - - // Create .beads directory - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0750); err != nil { - t.Fatalf("failed to create .beads dir: %v", err) - } - - // Create minimal issues.jsonl - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - if err := os.WriteFile(jsonlPath, []byte(""), 0644); err != nil { - t.Fatalf("failed to create issues.jsonl: %v", err) - } - - // Change to test directory - t.Chdir(tmpDir) - beads.ResetCaches() - git.ResetCaches() - defer func() { - beads.ResetCaches() - git.ResetCaches() - }() - - // Test 1: Verify orphan branch has no merge-base with main - t.Run("orphan branch has no merge-base", func(t *testing.T) { - orphanBranch := "test-orphan" - - // Create orphan branch using git directly (simulating what runMigrateSync does) - cmd := exec.Command("git", "checkout", "--orphan", orphanBranch) - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to create orphan branch: %v", err) - } - - // Remove all files from index (orphan starts with staged files) - cmd = exec.Command("git", "rm", "-rf", "--cached", ".") - cmd.Dir = tmpDir - _ = cmd.Run() // May fail if nothing staged - - // Clean working directory (like runMigrateSync does) - cmd = exec.Command("git", "clean", "-fd") - cmd.Dir = tmpDir - _ = cmd.Run() // Best effort - - // Create .beads directory on orphan branch - orphanBeadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(orphanBeadsDir, 0750); err != nil { - t.Fatalf("failed to create .beads dir on orphan: %v", err) - } - - // Create a commit on the orphan branch - orphanFile := filepath.Join(orphanBeadsDir, "test.txt") - if err := os.WriteFile(orphanFile, []byte("orphan content"), 0644); err != nil { - t.Fatalf("failed to create orphan file: %v", err) - } - cmd = exec.Command("git", "add", ".beads/test.txt") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to git add on orphan: %v", err) - } - cmd = exec.Command("git", "commit", "-m", "orphan initial") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to commit on orphan: %v", err) - } - - // Switch back to main branch (force to handle any conflicts) - cmd = exec.Command("git", "checkout", "-f", mainBranch) - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to switch back to %s: %v", mainBranch, err) - } - - // Verify orphan branch has no merge-base with main - // git merge-base should FAIL (exit code 1) for orphan branches - cmd = exec.Command("git", "merge-base", mainBranch, orphanBranch) - cmd.Dir = tmpDir - err := cmd.Run() - if err == nil { - t.Error("orphan branch should have no merge-base with main, but merge-base succeeded") - } - }) - - // Test 2: Verify regular branch (non-orphan) DOES have merge-base - t.Run("regular branch has merge-base", func(t *testing.T) { - regularBranch := "test-regular" - - // Create a regular branch (inherits history) - cmd := exec.Command("git", "branch", regularBranch) - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to create regular branch: %v", err) - } - - // Verify regular branch DOES have a merge-base with main - cmd = exec.Command("git", "merge-base", mainBranch, regularBranch) - cmd.Dir = tmpDir - err := cmd.Run() - if err != nil { - t.Error("regular branch should have merge-base with main, but merge-base failed") - } - }) -} - -func TestMigrateSyncOrphanWorktree(t *testing.T) { - // This test verifies that git worktrees can be created from orphan branches - // which is essential for orphan branches (now the default) to work with sparse checkout - - tmpDir, err := os.MkdirTemp("", "bd-migrate-sync-orphan-worktree-test") - if err != nil { - t.Fatalf("failed to create temp dir: %v", err) - } - defer os.RemoveAll(tmpDir) - - // Copy cached git template (bd-ktng optimization) - initGitTemplate() - if gitTemplateErr != nil { - t.Fatalf("git template init failed: %v", gitTemplateErr) - } - if err := copyGitDir(gitTemplateDir, tmpDir); err != nil { - t.Fatalf("failed to copy git template: %v", err) - } - - // Create initial commit on main - testFile := filepath.Join(tmpDir, "test.txt") - if err := os.WriteFile(testFile, []byte("main content"), 0644); err != nil { - t.Fatalf("failed to create test file: %v", err) - } - cmd := exec.Command("git", "add", ".") - cmd.Dir = tmpDir - _ = cmd.Run() - cmd = exec.Command("git", "commit", "-m", "initial") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to git commit: %v", err) - } - - // Get main branch name - cmd = exec.Command("git", "branch", "--show-current") - cmd.Dir = tmpDir - output, _ := cmd.Output() - mainBranch := strings.TrimSpace(string(output)) - - // Create orphan branch - orphanBranch := "orphan-sync" - cmd = exec.Command("git", "checkout", "--orphan", orphanBranch) - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to create orphan branch: %v", err) - } - - // Clean orphan branch - cmd = exec.Command("git", "rm", "-rf", "--cached", ".") - cmd.Dir = tmpDir - _ = cmd.Run() - cmd = exec.Command("git", "clean", "-fd") - cmd.Dir = tmpDir - _ = cmd.Run() - - // Create .beads content on orphan branch - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0750); err != nil { - t.Fatalf("failed to create .beads: %v", err) - } - if err := os.WriteFile(filepath.Join(beadsDir, "issues.jsonl"), []byte(""), 0644); err != nil { - t.Fatalf("failed to create issues.jsonl: %v", err) - } - cmd = exec.Command("git", "add", ".beads") - cmd.Dir = tmpDir - _ = cmd.Run() - cmd = exec.Command("git", "commit", "-m", "orphan initial") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to commit on orphan: %v", err) - } - - // Switch back to main - cmd = exec.Command("git", "checkout", "-f", mainBranch) - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to switch to main: %v", err) - } - - t.Run("worktree can be created from orphan branch", func(t *testing.T) { - worktreePath := filepath.Join(tmpDir, ".worktrees", orphanBranch) - - // Create worktree from orphan branch - cmd := exec.Command("git", "worktree", "add", worktreePath, orphanBranch) - cmd.Dir = tmpDir - output, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("failed to create worktree from orphan branch: %v\n%s", err, output) - } - - // Verify worktree exists - if _, err := os.Stat(worktreePath); os.IsNotExist(err) { - t.Error("worktree directory should exist") - } - - // Verify .beads exists in worktree (from orphan branch) - wtBeadsDir := filepath.Join(worktreePath, ".beads") - if _, err := os.Stat(wtBeadsDir); os.IsNotExist(err) { - t.Error(".beads should exist in worktree from orphan branch") - } - - // Verify main branch's test.txt does NOT exist in worktree - // (because orphan branch has no shared history) - wtTestFile := filepath.Join(worktreePath, "test.txt") - if _, err := os.Stat(wtTestFile); err == nil { - t.Error("test.txt from main branch should NOT exist in orphan worktree") - } - - // Cleanup worktree - cmd = exec.Command("git", "worktree", "remove", "--force", worktreePath) - cmd.Dir = tmpDir - _ = cmd.Run() - }) -} - -func TestMigrateSyncExistingBranchPreserved(t *testing.T) { - // This test verifies that existing sync branches (even non-orphan) are used as-is - // This ensures existing users aren't affected by the orphan-by-default change - - tmpDir, err := os.MkdirTemp("", "bd-migrate-sync-existing-test") - if err != nil { - t.Fatalf("failed to create temp dir: %v", err) - } - defer os.RemoveAll(tmpDir) - - // Copy cached git template (bd-ktng optimization) - initGitTemplate() - if gitTemplateErr != nil { - t.Fatalf("git template init failed: %v", gitTemplateErr) - } - if err := copyGitDir(gitTemplateDir, tmpDir); err != nil { - t.Fatalf("failed to copy git template: %v", err) - } - - // Create initial commit on main - testFile := filepath.Join(tmpDir, "test.txt") - if err := os.WriteFile(testFile, []byte("main content"), 0644); err != nil { - t.Fatalf("failed to create test file: %v", err) - } - cmd := exec.Command("git", "add", ".") - cmd.Dir = tmpDir - _ = cmd.Run() - cmd = exec.Command("git", "commit", "-m", "initial") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to git commit: %v", err) - } - - // Get main branch name - cmd = exec.Command("git", "branch", "--show-current") - cmd.Dir = tmpDir - output, _ := cmd.Output() - mainBranch := strings.TrimSpace(string(output)) - - // Create a REGULAR (non-orphan) branch to simulate existing setup - existingBranch := "existing-sync" - cmd = exec.Command("git", "branch", existingBranch) - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to create existing branch: %v", err) - } - - t.Run("existing non-orphan branch has merge-base", func(t *testing.T) { - // Verify the existing branch HAS a merge-base with main (it's not orphan) - cmd := exec.Command("git", "merge-base", mainBranch, existingBranch) - cmd.Dir = tmpDir - output, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("Expected merge-base to exist for non-orphan branch, but got error: %v\n%s", err, output) - } - mergeBase := strings.TrimSpace(string(output)) - if mergeBase == "" { - t.Fatal("Expected non-empty merge-base for non-orphan branch") - } - - // This proves the branch is NOT orphan, so if migrate sync uses it, - // it won't break existing user setups - }) - - t.Run("git show-ref detects existing branch", func(t *testing.T) { - // Verify git show-ref (used by branchExistsLocal) detects the branch - // This is the check that prevents orphan creation for existing branches - cmd := exec.Command("git", "show-ref", "--verify", "--quiet", "refs/heads/"+existingBranch) - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatal("Expected git show-ref to find existing branch") - } - }) -} - -func TestMigrateSyncOrphanMigration(t *testing.T) { - // This test verifies that --orphan flag migrates existing non-orphan branch to orphan - // by deleting and recreating it - - tmpDir, err := os.MkdirTemp("", "bd-migrate-sync-orphan-migration-test") - if err != nil { - t.Fatalf("failed to create temp dir: %v", err) - } - defer os.RemoveAll(tmpDir) - - // Copy cached git template (bd-ktng optimization) - initGitTemplate() - if gitTemplateErr != nil { - t.Fatalf("git template init failed: %v", gitTemplateErr) - } - if err := copyGitDir(gitTemplateDir, tmpDir); err != nil { - t.Fatalf("failed to copy git template: %v", err) - } - - // Create initial commit on main - testFile := filepath.Join(tmpDir, "test.txt") - if err := os.WriteFile(testFile, []byte("main content"), 0644); err != nil { - t.Fatalf("failed to create test file: %v", err) - } - cmd := exec.Command("git", "add", ".") - cmd.Dir = tmpDir - _ = cmd.Run() - cmd = exec.Command("git", "commit", "-m", "initial") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to git commit: %v", err) - } - - // Get main branch name - cmd = exec.Command("git", "branch", "--show-current") - cmd.Dir = tmpDir - output, _ := cmd.Output() - mainBranch := strings.TrimSpace(string(output)) - - // Create a REGULAR (non-orphan) branch - syncBranch := "beads-sync" - cmd = exec.Command("git", "branch", syncBranch) - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to create sync branch: %v", err) - } - - t.Run("non-orphan branch has merge-base before migration", func(t *testing.T) { - // Verify it HAS merge-base (not orphan yet) - cmd := exec.Command("git", "merge-base", mainBranch, syncBranch) - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatal("Expected merge-base to exist before migration") - } - }) - - t.Run("migration converts to orphan", func(t *testing.T) { - // Simulate what --orphan flag does: delete and recreate as orphan - // Delete existing branch - cmd := exec.Command("git", "branch", "-D", syncBranch) - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to delete branch: %v", err) - } - - // Create orphan branch - cmd = exec.Command("git", "checkout", "--orphan", syncBranch) - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to create orphan branch: %v", err) - } - - // Remove staged files - cmd = exec.Command("git", "rm", "-rf", "--cached", ".") - cmd.Dir = tmpDir - _ = cmd.Run() - - // Clean working directory - cmd = exec.Command("git", "clean", "-fd") - cmd.Dir = tmpDir - _ = cmd.Run() - - // Create .beads and commit - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0750); err != nil { - t.Fatalf("failed to create .beads: %v", err) - } - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - if err := os.WriteFile(jsonlPath, []byte(""), 0644); err != nil { - t.Fatalf("failed to create issues.jsonl: %v", err) - } - cmd = exec.Command("git", "add", ".beads") - cmd.Dir = tmpDir - _ = cmd.Run() - cmd = exec.Command("git", "commit", "-m", "init beads on orphan") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to commit on orphan: %v", err) - } - - // Switch back to main - cmd = exec.Command("git", "checkout", mainBranch) - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to checkout main: %v", err) - } - - // Verify NO merge-base after migration (orphan) - cmd = exec.Command("git", "merge-base", mainBranch, syncBranch) - cmd.Dir = tmpDir - output, err := cmd.CombinedOutput() - if err == nil { - t.Fatalf("Expected no merge-base after migration to orphan, but got: %s", output) - } - }) -} - -func TestHasChangesInWorktreeDir(t *testing.T) { - // Create a temp directory with a git repo - tmpDir, err := os.MkdirTemp("", "bd-worktree-changes-test") - if err != nil { - t.Fatalf("failed to create temp dir: %v", err) - } - defer os.RemoveAll(tmpDir) - - // Copy cached git template (bd-ktng optimization) - initGitTemplate() - if gitTemplateErr != nil { - t.Fatalf("git template init failed: %v", gitTemplateErr) - } - if err := copyGitDir(gitTemplateDir, tmpDir); err != nil { - t.Fatalf("failed to copy git template: %v", err) - } - - // Create and commit initial file - testFile := filepath.Join(tmpDir, "test.txt") - if err := os.WriteFile(testFile, []byte("test"), 0644); err != nil { - t.Fatalf("failed to create test file: %v", err) - } - cmd := exec.Command("git", "add", ".") - cmd.Dir = tmpDir - _ = cmd.Run() - cmd = exec.Command("git", "commit", "-m", "initial") - cmd.Dir = tmpDir - _ = cmd.Run() - - ctx := context.Background() - - // No changes initially - hasChanges, err := hasChangesInWorktreeDir(ctx, tmpDir) - if err != nil { - t.Fatalf("hasChangesInWorktreeDir failed: %v", err) - } - if hasChanges { - t.Error("should have no changes initially") - } - - // Add uncommitted file - newFile := filepath.Join(tmpDir, "new.txt") - if err := os.WriteFile(newFile, []byte("new"), 0644); err != nil { - t.Fatalf("failed to create new file: %v", err) - } - - hasChanges, err = hasChangesInWorktreeDir(ctx, tmpDir) - if err != nil { - t.Fatalf("hasChangesInWorktreeDir failed: %v", err) - } - if !hasChanges { - t.Error("should have changes after adding file") - } -} diff --git a/cmd/bd/sync.go b/cmd/bd/sync.go index ce2c22ee1..864e22cc9 100644 --- a/cmd/bd/sync.go +++ b/cmd/bd/sync.go @@ -1,131 +1,32 @@ package main import ( - "context" - "encoding/json" "fmt" - "os" - "path/filepath" "strings" - "time" - "github.com/gofrs/flock" "github.com/spf13/cobra" - "github.com/steveyegge/beads/internal/beads" - "github.com/steveyegge/beads/internal/config" - - "github.com/steveyegge/beads/internal/syncbranch" ) -// SyncBranchContext holds sync-branch configuration detected from the store. -// This consolidates the repeated pattern of checking for sync-branch config. -type SyncBranchContext struct { - Branch string // Sync branch name, empty if not configured - RepoRoot string // Git repository root path -} - -// IsConfigured returns true if a sync branch is configured. -func (s *SyncBranchContext) IsConfigured() bool { - return s.Branch != "" -} - -// getSyncBranchContext detects sync-branch configuration from the store. -// Returns a context with empty Branch if not configured or on error. -func getSyncBranchContext(ctx context.Context) *SyncBranchContext { - sbc := &SyncBranchContext{} - if err := ensureStoreActive(); err != nil || store == nil { - return sbc - } - // Best effort: if syncbranch lookup fails, we proceed without sync branch info - if sb, _ := syncbranch.Get(ctx, store); sb != "" { - sbc.Branch = sb - if rc, err := beads.GetRepoContext(); err == nil { - sbc.RepoRoot = rc.RepoRoot - } - } - return sbc -} - -// commitAndPushBeads commits and pushes .beads changes using the appropriate method. -// When sync-branch is configured, uses worktree-based commit/push. -// Otherwise, uses standard git commit/push on the current branch. -func commitAndPushBeads(ctx context.Context, sbc *SyncBranchContext, jsonlPath string, noPush bool, message string) error { - if sbc.IsConfigured() { - fmt.Printf("→ Committing to sync branch '%s'...\n", sbc.Branch) - commitResult, err := syncbranch.CommitToSyncBranch(ctx, sbc.RepoRoot, sbc.Branch, jsonlPath, !noPush) - if err != nil { - return fmt.Errorf("committing to sync branch: %w", err) - } - if commitResult.Committed { - fmt.Printf(" Committed: %s\n", commitResult.Message) - if commitResult.Pushed { - fmt.Println(" Pushed to remote") - } - } else { - fmt.Println("→ No changes to commit") - } - return nil - } - - // Standard git workflow - hasChanges, err := gitHasBeadsChanges(ctx) - if err != nil { - return fmt.Errorf("checking git status: %w", err) - } - - if hasChanges { - fmt.Println("→ Committing changes...") - if err := gitCommitBeadsDir(ctx, message); err != nil { - return fmt.Errorf("committing: %w", err) - } - } else { - fmt.Println("→ No changes to commit") - } - - // Push to remote - if !noPush && hasChanges { - fmt.Println("→ Pushing to remote...") - if err := gitPush(ctx, ""); err != nil { - return fmt.Errorf("pushing: %w", err) - } - } - - return nil -} - var syncCmd = &cobra.Command{ Use: "sync", GroupID: "sync", - Short: "Export database to JSONL (sync with git)", - Long: `Export database to JSONL for git synchronization. + Short: "Sync Dolt database (commit, push, pull)", + Long: `Sync operations for the Dolt database. -By default, exports the current database state to JSONL. -Does NOT stage or commit - that's the user's job. +By default, commits pending changes and pushes to the Dolt remote. Commands: - bd sync Export to JSONL (prep for push) - bd sync --import Import from JSONL (after pull) - bd sync --status Show sync state - bd sync --resolve Resolve conflicts (uses configured strategy) - bd sync --force Force full export/import (skip incremental) - bd sync --full Full sync: pull → merge → export → commit → push (legacy) + bd sync Commit and push to Dolt remote + bd sync --pull Pull from Dolt remote + bd sync --import Import from JSONL file into database + bd sync --export Export database to JSONL file -Conflict Resolution: - bd sync --resolve Use configured conflict.strategy - bd sync --resolve --ours Keep local versions - bd sync --resolve --theirs Keep remote versions - bd sync --resolve --manual Interactive resolution with prompts - -The --manual flag shows a diff for each conflict and prompts you to choose: - l/local - Keep local version - r/remote - Keep remote version - m/merge - Auto-merge (LWW for scalars, union for collections) - s/skip - Skip (keep local, conflict remains for later) - a/all - Accept auto-merge for all remaining conflicts - q/quit - Quit and skip all remaining conflicts - d/diff - Show full JSON diff - -The --full flag provides the legacy full sync behavior for backwards compatibility.`, +Examples: + bd sync # Commit + push + bd sync --pull # Pull from remote + bd sync --import # Import JSONL → Dolt + bd sync --export # Export Dolt → JSONL + bd sync -m "updated beads" # Custom commit message`, Run: func(cmd *cobra.Command, _ []string) { CheckReadonly("sync") ctx := rootCtx @@ -133,673 +34,126 @@ The --full flag provides the legacy full sync behavior for backwards compatibili message, _ := cmd.Flags().GetString("message") dryRun, _ := cmd.Flags().GetBool("dry-run") noPush, _ := cmd.Flags().GetBool("no-push") - noPull, _ := cmd.Flags().GetBool("no-pull") - renameOnImport, _ := cmd.Flags().GetBool("rename-on-import") - flushOnly, _ := cmd.Flags().GetBool("flush-only") - importOnly, _ := cmd.Flags().GetBool("import-only") importFlag, _ := cmd.Flags().GetBool("import") - status, _ := cmd.Flags().GetBool("status") - merge, _ := cmd.Flags().GetBool("merge") - fromMain, _ := cmd.Flags().GetBool("from-main") - noGitHistory, _ := cmd.Flags().GetBool("no-git-history") - squash, _ := cmd.Flags().GetBool("squash") - checkIntegrity, _ := cmd.Flags().GetBool("check") - acceptRebase, _ := cmd.Flags().GetBool("accept-rebase") - fullSync, _ := cmd.Flags().GetBool("full") - resolve, _ := cmd.Flags().GetBool("resolve") - resolveOurs, _ := cmd.Flags().GetBool("ours") - resolveTheirs, _ := cmd.Flags().GetBool("theirs") - resolveManual, _ := cmd.Flags().GetBool("manual") - forceFlag, _ := cmd.Flags().GetBool("force") + importOnly, _ := cmd.Flags().GetBool("import-only") + exportFlag, _ := cmd.Flags().GetBool("export") + flushOnly, _ := cmd.Flags().GetBool("flush-only") + pullFlag, _ := cmd.Flags().GetBool("pull") - // --import is shorthand for --import-only - if importFlag { - importOnly = true + // Aliases + if importOnly { + importFlag = true + } + if flushOnly { + exportFlag = true } - // If --no-push not explicitly set, check no-push config - if !cmd.Flags().Changed("no-push") { - noPush = config.GetBool("no-push") - } - - // Ensure direct store is active for sync operations. if err := ensureStoreActive(); err != nil { FatalError("failed to initialize store: %v", err) } - // Resolve noGitHistory based on fromMain (fixes #417) - noGitHistory = resolveNoGitHistoryForFromMain(fromMain, noGitHistory) - - // Handle --set-mode flag - setMode, _ := cmd.Flags().GetString("set-mode") - if setMode != "" { - if err := SetSyncMode(ctx, store, setMode); err != nil { - FatalError("failed to set sync mode: %v", err) + // Import mode: JSONL → Dolt + if importFlag { + jsonlPath := findJSONLPath() + if jsonlPath == "" { + FatalError("no JSONL file found (no .beads directory)") } - fmt.Printf("✓ Sync mode set to: %s (%s)\n", setMode, SyncModeDescription(setMode)) - return - } - - // Find JSONL path - jsonlPath := findJSONLPath() - if jsonlPath == "" { - FatalError("not in a bd workspace (no .beads directory found)") - } - - // If status mode, show sync state (new format per spec) - if status { - if err := showSyncStateStatus(ctx, jsonlPath); err != nil { - FatalError("%v", err) - } - return - } - - // If resolve mode, resolve conflicts - if resolve { - strategy := config.GetConflictStrategy() // use configured default - if resolveOurs { - strategy = config.ConflictStrategyOurs - } else if resolveTheirs { - strategy = config.ConflictStrategyTheirs - } else if resolveManual { - strategy = config.ConflictStrategyManual - } - if err := resolveSyncConflicts(ctx, jsonlPath, strategy, dryRun); err != nil { - FatalError("%v", err) - } - return - } - - // If check mode, run pre-sync integrity checks - if checkIntegrity { - showSyncIntegrityCheck(ctx, jsonlPath) - return - } - - // If merge mode, merge sync branch to main - if merge { - if err := mergeSyncBranch(ctx, dryRun); err != nil { - FatalError("%v", err) - } - return - } - - // If from-main mode, one-way sync from main branch (gt-ick9: ephemeral branch support) - if fromMain { - if err := doSyncFromMain(ctx, jsonlPath, renameOnImport, dryRun, noGitHistory); err != nil { - FatalError("%v", err) - } - return - } - - // If import-only mode, just import and exit - // Use inline import to avoid subprocess path resolution issues with .beads/redirect (bd-ysal) - if importOnly { if dryRun { fmt.Println("→ [DRY RUN] Would import from JSONL") - } else { - fmt.Println("→ Importing from JSONL...") - if err := importFromJSONLInline(ctx, jsonlPath, renameOnImport, noGitHistory, false); err != nil { - FatalError("importing: %v", err) - } - fmt.Println("✓ Import complete") - } - return - } - - // If flush-only mode, just export and exit - if flushOnly { - if dryRun { - fmt.Println("→ [DRY RUN] Would export pending changes to JSONL") - } else { - if err := exportToJSONL(ctx, jsonlPath); err != nil { - FatalError("exporting: %v", err) - } - } - return - } - - // If squash mode, export to JSONL but skip git operations - // This accumulates changes for a single commit later - if squash { - if dryRun { - fmt.Println("→ [DRY RUN] Would export pending changes to JSONL (squash mode)") - } else { - fmt.Println("→ Exporting pending changes to JSONL (squash mode)...") - if err := exportToJSONL(ctx, jsonlPath); err != nil { - FatalError("exporting: %v", err) - } - fmt.Println("✓ Changes accumulated in JSONL") - fmt.Println(" Run 'bd sync' (without --squash) to commit all accumulated changes") - } - return - } - - // DEFAULT BEHAVIOR: Export to JSONL only (per spec) - // Does NOT stage or commit - that's the user's job. - // Use --full for legacy full sync behavior (pull → merge → export → commit → push) - if !fullSync { - if err := doExportSync(ctx, jsonlPath, forceFlag, dryRun); err != nil { - FatalError("%v", err) - } - return - } - - // FULL SYNC MODE (--full flag): Legacy behavior - // Pull → Merge → Export → Commit → Push - - // Check if we're in a git repository - if !isGitRepo() { - FatalErrorWithHint("not in a git repository", "run 'git init' to initialize a repository") - } - - // Preflight: check for merge/rebase in progress - if inMerge, err := gitHasUnmergedPaths(); err != nil { - FatalError("checking git state: %v", err) - } else if inMerge { - FatalErrorWithHint("unmerged paths or merge in progress", "resolve conflicts, run 'bd import' if needed, then 'bd sync' again") - } - - // GH#885: Preflight check for uncommitted JSONL changes - // This detects when a previous sync exported but failed before commit, - // leaving the JSONL in an inconsistent state across worktrees. - if hasUncommitted, err := gitHasUncommittedBeadsChanges(ctx); err != nil { - fmt.Fprintf(os.Stderr, "Warning: failed to check for uncommitted changes: %v\n", err) - } else if hasUncommitted { - fmt.Println("→ Detected uncommitted JSONL changes (possible incomplete sync)") - fmt.Println("→ Re-exporting from database to reconcile state...") - // Force a fresh export to ensure JSONL matches current DB state - if err := exportToJSONL(ctx, jsonlPath); err != nil { - FatalError("re-exporting to reconcile state: %v", err) - } - fmt.Println("✓ State reconciled") - } - - // GH#638: Check sync.branch BEFORE upstream check - // When sync.branch is configured, we should use worktree-based sync even if - // the current branch has no upstream (e.g., detached HEAD in jj, git worktrees) - sbc := getSyncBranchContext(ctx) - - // GH#1166: Block sync if currently on the sync branch - // This must happen BEFORE worktree operations - after entering a worktree, - // GetCurrentBranch() would return the worktree's branch, not the original. - if sbc.IsConfigured() { - if syncbranch.IsSyncBranchSameAsCurrent(ctx, sbc.Branch) { - FatalError("Cannot sync to '%s': it's your current branch. "+ - "Checkout a different branch first, or use a dedicated sync branch like 'beads-sync'.", - sbc.Branch) - } - } - - // bd-wayc3: Check for redirect + sync-branch incompatibility - // Redirect and sync-branch are mutually exclusive: - // - Redirect says: "My database is in another repo (I am a client)" - // - Sync-branch says: "I own my database and sync it myself via worktree" - // When redirect is active, the sync-branch worktree operations fail because - // the beads files are in a different git repo than the current working directory. - redirectInfo := beads.GetRedirectInfo() - if redirectInfo.IsRedirected { - if sbc.IsConfigured() { - fmt.Printf("⚠️ Redirect active (-> %s), skipping sync-branch operations\n", redirectInfo.TargetDir) - fmt.Println(" Hint: Redirected clones should not have sync-branch configured") - fmt.Println(" The owner of the target .beads directory handles sync-branch") - } else { - fmt.Printf("→ Redirect active (-> %s)\n", redirectInfo.TargetDir) - } - // For redirected clones, just do import/export - skip all git operations - // The target repo's owner (e.g., mayor) handles git commit/push via sync-branch - if dryRun { - fmt.Println("→ [DRY RUN] Would export to JSONL (redirected clone, git operations skipped)") - fmt.Println("✓ Dry run complete (no changes made)") - } else { - fmt.Println("→ Exporting to JSONL (redirected clone, skipping git operations)...") - if err := exportToJSONL(ctx, jsonlPath); err != nil { - FatalError("exporting: %v", err) - } - fmt.Println("✓ Export complete (target repo owner handles git sync)") - } - return - } - - // Preflight: check for upstream tracking - // If no upstream, automatically switch to --from-main mode (gt-ick9: ephemeral branch support) - // GH#638: Skip this fallback if sync.branch is explicitly configured - if !noPull && !gitHasUpstream() && !sbc.IsConfigured() { - if hasGitRemote(ctx) { - // Remote exists but no upstream - use from-main mode - fmt.Println("→ No upstream configured, using --from-main mode") - // Force noGitHistory=true for auto-detected from-main mode (fixes #417) - if err := doSyncFromMain(ctx, jsonlPath, renameOnImport, dryRun, true); err != nil { - FatalError("%v", err) - } return } - // If no remote at all, gitPull/gitPush will gracefully skip + fmt.Println("→ Importing from JSONL...") + if err := importFromJSONL(ctx, jsonlPath); err != nil { + FatalError("importing: %v", err) + } + fmt.Println("✓ Import complete") + return } - // Pull-first sync: Pull → Merge → Export → Commit → Push - // This eliminates the export-before-pull data loss pattern (#911) by - // seeing remote changes before exporting local state. - if err := doPullFirstSync(ctx, jsonlPath, renameOnImport, noGitHistory, dryRun, noPush, noPull, message, acceptRebase, sbc); err != nil { - FatalError("%v", err) + // Export mode: Dolt → JSONL + if exportFlag { + jsonlPath := findJSONLPath() + if jsonlPath == "" { + FatalError("no JSONL file found (no .beads directory)") + } + if dryRun { + fmt.Println("→ [DRY RUN] Would export to JSONL") + return + } + fmt.Println("→ Exporting to JSONL...") + if err := exportToJSONL(ctx, jsonlPath); err != nil { + FatalError("exporting: %v", err) + } + fmt.Println("✓ Export complete") + return } + + // Pull mode: Pull from Dolt remote + if pullFlag { + if dryRun { + fmt.Println("→ [DRY RUN] Would pull from Dolt remote") + return + } + fmt.Println("→ Pulling from Dolt remote...") + if err := store.Pull(ctx); err != nil { + if strings.Contains(err.Error(), "remote") { + fmt.Println("⚠ No Dolt remote configured") + } else { + FatalError("dolt pull failed: %v", err) + } + } else { + fmt.Println("✓ Pulled from Dolt remote") + } + return + } + + // Default: Commit + Push to Dolt remote + if dryRun { + fmt.Println("→ [DRY RUN] Would commit and push to Dolt remote") + return + } + + // Commit + fmt.Println("→ Committing to Dolt...") + commandDidExplicitDoltCommit = true + commitMsg := message + if commitMsg == "" { + commitMsg = "bd sync" + } + if err := store.Commit(ctx, commitMsg); err != nil { + if !strings.Contains(err.Error(), "nothing to commit") { + FatalError("dolt commit failed: %v", err) + } + fmt.Println(" Nothing to commit") + } + + // Push + if !noPush { + fmt.Println("→ Pushing to Dolt remote...") + if err := store.Push(ctx); err != nil { + if strings.Contains(err.Error(), "remote") { + fmt.Println("⚠ No Dolt remote configured, skipping push") + } else { + FatalError("dolt push failed: %v", err) + } + } else { + fmt.Println("✓ Pushed to Dolt remote") + } + } + + fmt.Println("\n✓ Sync complete") }, } -// doPullFirstSync implements the pull-first sync flow: -// Pull → Merge → Export → Commit → Push -// -// This eliminates the export-before-pull data loss pattern (#911) by -// seeing remote changes before exporting local state. -// -// The 3-way merge uses: -// - Base state: Last successful sync (.beads/sync_base.jsonl) -// - Local state: Current database contents -// - Remote state: JSONL after git pull -// -// When noPull is true, skips the pull/merge steps and just does: -// Export → Commit → Push -func doPullFirstSync(ctx context.Context, jsonlPath string, renameOnImport, noGitHistory, dryRun, noPush, noPull bool, message string, acceptRebase bool, sbc *SyncBranchContext) error { - beadsDir := filepath.Dir(jsonlPath) - _ = acceptRebase // Reserved for future sync branch force-push detection - - if dryRun { - if noPull { - fmt.Println("→ [DRY RUN] Would export pending changes to JSONL") - fmt.Println("→ [DRY RUN] Would commit changes") - if !noPush { - fmt.Println("→ [DRY RUN] Would push to remote") - } - } else { - fmt.Println("→ [DRY RUN] Would pull from remote") - fmt.Println("→ [DRY RUN] Would load base state from sync_base.jsonl") - fmt.Println("→ [DRY RUN] Would merge base, local, and remote issues (3-way)") - fmt.Println("→ [DRY RUN] Would export merged state to JSONL") - fmt.Println("→ [DRY RUN] Would update sync_base.jsonl") - fmt.Println("→ [DRY RUN] Would commit and push changes") - } - fmt.Println("\n✓ Dry run complete (no changes made)") - return nil - } - - // If noPull, use simplified export-only flow - if noPull { - return doExportOnlySync(ctx, jsonlPath, noPush, message) - } - - // Step 1: Load local state from DB BEFORE pulling - // This captures the current DB state before remote changes arrive - if err := ensureStoreActive(); err != nil { - return fmt.Errorf("activating store: %w", err) - } - - localIssues, err := store.SearchIssues(ctx, "", beads.IssueFilter{}) - if err != nil { - return fmt.Errorf("loading local issues: %w", err) - } - fmt.Printf("→ Loaded %d local issues from database\n", len(localIssues)) - - // Acquire exclusive lock to prevent concurrent sync corruption - lockPath := filepath.Join(beadsDir, ".sync.lock") - lock := flock.New(lockPath) - locked, err := lock.TryLock() - if err != nil { - return fmt.Errorf("acquiring sync lock: %w", err) - } - if !locked { - // Check if lock file is stale (from a crashed sync process). - // On Unix, flock is released when a process exits, so TryLock normally - // succeeds after a crash. This handles edge cases (NFS, hung processes). - if cleanedUp := cleanStaleSyncLock(lockPath); cleanedUp { - lock = flock.New(lockPath) - locked, err = lock.TryLock() - if err != nil { - return fmt.Errorf("acquiring sync lock after stale cleanup: %w", err) - } - } - if !locked { - return fmt.Errorf("another sync is in progress (lock: %s)", lockPath) - } - } - defer func() { _ = lock.Unlock() }() - - // Step 2: Load base state (last successful sync) - fmt.Println("→ Loading base state...") - baseIssues, err := loadBaseState(beadsDir) - if err != nil { - return fmt.Errorf("loading base state: %w", err) - } - if baseIssues == nil { - fmt.Println(" No base state found (first sync)") - } else { - fmt.Printf(" Loaded %d issues from base state\n", len(baseIssues)) - } - - // Step 3: Pull from remote - // Mode-specific pull behavior: - // - dolt-native/belt-and-suspenders with Dolt remote: Pull from Dolt - // - sync.branch configured: Pull from sync branch via worktree - // - Default (git-portable): Normal git pull - syncMode := GetSyncMode(ctx, store) - shouldUseDolt := ShouldUseDoltRemote(ctx, store) - - if shouldUseDolt { - // Dolt pull for dolt-native and belt-and-suspenders modes - fmt.Println("→ Pulling from Dolt remote...") - if err := store.Pull(ctx); err != nil { - // Don't fail if no remote configured - if strings.Contains(err.Error(), "remote") { - fmt.Println("⚠ No Dolt remote configured, skipping Dolt pull") - } else { - return fmt.Errorf("dolt pull failed: %w", err) - } - } else { - fmt.Println("✓ Pulled from Dolt remote") - } - // For belt-and-suspenders, continue with git pull even if Dolt pull failed - } - - // Git-based pull (for git-portable, belt-and-suspenders, or when Dolt not available) - // In dolt-native mode, skip git pull for JSONL (JSONL is export-only backup) - if syncMode != SyncModeDoltNative { - if sbc.IsConfigured() { - fmt.Printf("→ Pulling from sync branch '%s'...\n", sbc.Branch) - pullResult, err := syncbranch.PullFromSyncBranch(ctx, sbc.RepoRoot, sbc.Branch, jsonlPath, false) - if err != nil { - return fmt.Errorf("pulling from sync branch: %w", err) - } - // Display any safety warnings from the pull - for _, warning := range pullResult.SafetyWarnings { - fmt.Fprintln(os.Stderr, warning) - } - if pullResult.Merged { - fmt.Println(" Merged divergent sync branch histories") - } else if pullResult.FastForwarded { - fmt.Println(" Fast-forwarded to remote") - } - } else { - fmt.Println("→ Pulling from remote...") - if err := gitPull(ctx, ""); err != nil { - return fmt.Errorf("pulling: %w", err) - } - } - } - - // For dolt-native mode, we're done after pulling from Dolt remote - // Dolt handles merging internally, no JSONL workflow needed - if syncMode == SyncModeDoltNative { - fmt.Println("\n✓ Sync complete (dolt-native mode)") - return nil - } - - // Step 4: Load remote state from JSONL (after pull) - remoteIssues, err := loadIssuesFromJSONL(jsonlPath) - if err != nil { - return fmt.Errorf("loading remote issues from JSONL: %w", err) - } - fmt.Printf(" Loaded %d remote issues from JSONL\n", len(remoteIssues)) - - // Step 5: Perform 3-way merge - fmt.Println("→ Merging base, local, and remote issues (3-way)...") - mergeResult := MergeIssues(baseIssues, localIssues, remoteIssues) - - // Report merge results - localCount, remoteCount, sameCount := 0, 0, 0 - for _, strategy := range mergeResult.Strategy { - switch strategy { - case StrategyLocal: - localCount++ - case StrategyRemote: - remoteCount++ - case StrategySame: - sameCount++ - } - } - fmt.Printf(" Merged: %d issues total\n", len(mergeResult.Merged)) - fmt.Printf(" Local wins: %d, Remote wins: %d, Same: %d, Conflicts (LWW): %d\n", - localCount, remoteCount, sameCount, mergeResult.Conflicts) - - // Display manual conflicts that need user resolution - if len(mergeResult.ManualConflicts) > 0 { - displayManualConflicts(mergeResult.ManualConflicts) - } - - // Step 6: Import merged state to DB - // First, write merged result to JSONL so import can read it - fmt.Println("→ Writing merged state to JSONL...") - if err := writeMergedStateToJSONL(jsonlPath, mergeResult.Merged); err != nil { - return fmt.Errorf("writing merged state: %w", err) - } - - fmt.Println("→ Importing merged state to database...") - if err := importFromJSONL(ctx, jsonlPath, renameOnImport, noGitHistory); err != nil { - return fmt.Errorf("importing merged state: %w", err) - } - - // Step 7: Export from DB to JSONL (ensures DB is source of truth) - fmt.Println("→ Exporting from database to JSONL...") - if err := exportToJSONL(ctx, jsonlPath); err != nil { - return fmt.Errorf("exporting: %w", err) - } - - // Step 8 & 9: Commit and push changes - if err := commitAndPushBeads(ctx, sbc, jsonlPath, noPush, message); err != nil { - return err - } - - // Step 10: Update base state for next sync (after successful push) - // Base state only updates after confirmed push to ensure consistency - fmt.Println("→ Updating base state...") - // Reload from exported JSONL to capture any normalization from import/export cycle - finalIssues, err := loadIssuesFromJSONL(jsonlPath) - if err != nil { - return fmt.Errorf("reloading final state: %w", err) - } - if err := saveBaseState(beadsDir, finalIssues); err != nil { - return fmt.Errorf("saving base state: %w", err) - } - fmt.Printf(" Saved %d issues to base state\n", len(finalIssues)) - - // Step 11: Clear sync state on successful sync - if bd := beads.FindBeadsDir(); bd != "" { - _ = ClearSyncState(bd) // Best effort: stale state is harmless - } - - fmt.Println("\n✓ Sync complete") - return nil -} - -// doExportOnlySync handles the --no-pull case: just export, commit, and push -func doExportOnlySync(ctx context.Context, jsonlPath string, noPush bool, message string) error { - beadsDir := filepath.Dir(jsonlPath) - - // Acquire exclusive lock to prevent concurrent sync corruption - lockPath := filepath.Join(beadsDir, ".sync.lock") - lock := flock.New(lockPath) - locked, err := lock.TryLock() - if err != nil { - return fmt.Errorf("acquiring sync lock: %w", err) - } - if !locked { - // Check if lock file is stale (from a crashed sync process). - if cleanedUp := cleanStaleSyncLock(lockPath); cleanedUp { - lock = flock.New(lockPath) - locked, err = lock.TryLock() - if err != nil { - return fmt.Errorf("acquiring sync lock after stale cleanup: %w", err) - } - } - if !locked { - return fmt.Errorf("another sync is in progress (lock: %s)", lockPath) - } - } - defer func() { _ = lock.Unlock() }() - - // Pre-export integrity checks - if err := ensureStoreActive(); err == nil && store != nil { - if err := validatePreExport(ctx, store, jsonlPath); err != nil { - return fmt.Errorf("pre-export validation failed: %w", err) - } - if err := checkDuplicateIDs(ctx, store); err != nil { - return fmt.Errorf("database corruption detected: %w", err) - } - if orphaned, err := checkOrphanedDeps(ctx, store); err != nil { - fmt.Fprintf(os.Stderr, "Warning: orphaned dependency check failed: %v\n", err) - } else if len(orphaned) > 0 { - fmt.Fprintf(os.Stderr, "Warning: found %d orphaned dependencies: %v\n", len(orphaned), orphaned) - } - } - - // Template validation before export - if err := validateOpenIssuesForSync(ctx); err != nil { - return err - } - - // GH#1173: Detect sync-branch configuration and use appropriate commit method - sbc := getSyncBranchContext(ctx) - - fmt.Println("→ Exporting pending changes to JSONL...") - if err := exportToJSONL(ctx, jsonlPath); err != nil { - return fmt.Errorf("exporting: %w", err) - } - - // Commit and push using the appropriate method (sync-branch worktree or regular git) - if err := commitAndPushBeads(ctx, sbc, jsonlPath, noPush, message); err != nil { - return err - } - - // Clear sync state on successful sync - if bd := beads.FindBeadsDir(); bd != "" { - _ = ClearSyncState(bd) // Best effort: stale state is harmless - } - - fmt.Println("\n✓ Sync complete") - return nil -} - -// writeMergedStateToJSONL writes merged issues to JSONL file -func writeMergedStateToJSONL(path string, issues []*beads.Issue) error { - tempPath := fmt.Sprintf("%s.tmp.%d.%d", path, os.Getpid(), time.Now().UnixNano()) - file, err := os.Create(tempPath) //nolint:gosec // path is trusted internal beads path - if err != nil { - return err - } - - encoder := json.NewEncoder(file) - encoder.SetEscapeHTML(false) - - for _, issue := range issues { - if err := encoder.Encode(issue); err != nil { - _ = file.Close() // Best-effort cleanup - _ = os.Remove(tempPath) - return err - } - } - - if err := file.Close(); err != nil { - _ = os.Remove(tempPath) // Best-effort cleanup - return err - } - - return os.Rename(tempPath, path) -} - -// doExportSync exports the current database state based on sync mode. -// - git-portable, realtime: Export to JSONL -// - dolt-native: Commit and push to Dolt remote (skip JSONL) -// - belt-and-suspenders: Both JSONL export and Dolt push -// Does NOT stage or commit to git - that's the user's job. -func doExportSync(ctx context.Context, jsonlPath string, _, dryRun bool) error { - if err := ensureStoreActive(); err != nil { - return fmt.Errorf("failed to initialize store: %w", err) - } - - shouldExportJSONL := ShouldExportJSONL(ctx, store) - shouldUseDolt := ShouldUseDoltRemote(ctx, store) - - if dryRun { - if shouldExportJSONL { - fmt.Println("→ [DRY RUN] Would export database to JSONL") - } - if shouldUseDolt { - fmt.Println("→ [DRY RUN] Would commit and push to Dolt remote") - } - return nil - } - - // Handle Dolt remote operations for dolt-native and belt-and-suspenders modes - if shouldUseDolt { - fmt.Println("→ Committing to Dolt...") - // We are explicitly creating a Dolt commit inside sync; avoid redundant auto-commit in PersistentPostRun. - commandDidExplicitDoltCommit = true - if err := store.Commit(ctx, "bd sync: auto-commit"); err != nil { - // Ignore "nothing to commit" errors - if !strings.Contains(err.Error(), "nothing to commit") { - return fmt.Errorf("dolt commit failed: %w", err) - } - } - - fmt.Println("→ Pushing to Dolt remote...") - if err := store.Push(ctx); err != nil { - // Don't fail if no remote configured - if !strings.Contains(err.Error(), "remote") { - return fmt.Errorf("dolt push failed: %w", err) - } - fmt.Println("⚠ No Dolt remote configured, skipping push") - } else { - fmt.Println("✓ Pushed to Dolt remote") - } - } - - // Export to JSONL for git-portable, realtime, and belt-and-suspenders modes - if shouldExportJSONL { - fmt.Println("Exporting beads to JSONL...") - - // Export to JSONL (uses incremental export for large repos) - result, err := exportToJSONLIncrementalDeferred(ctx, jsonlPath) - if err != nil { - return fmt.Errorf("exporting: %w", err) - } - - // Finalize export (update metadata) - finalizeExport(ctx, result) - - // Report results - totalCount := 0 - if result != nil { - totalCount = len(result.ExportedIDs) - } - - fmt.Printf("✓ Exported %d issues\n", totalCount) - fmt.Printf("✓ %s updated\n", jsonlPath) - } - - return nil -} - func init() { - syncCmd.Flags().StringP("message", "m", "", "Commit message (default: auto-generated)") + syncCmd.Flags().StringP("message", "m", "", "Commit message (default: 'bd sync')") syncCmd.Flags().Bool("dry-run", false, "Preview sync without making changes") syncCmd.Flags().Bool("no-push", false, "Skip pushing to remote") - syncCmd.Flags().Bool("no-pull", false, "Skip pulling from remote") - syncCmd.Flags().Bool("rename-on-import", false, "Rename imported issues to match database prefix (updates all references)") - syncCmd.Flags().Bool("flush-only", false, "Only export pending changes to JSONL (skip git operations)") - syncCmd.Flags().Bool("squash", false, "Accumulate changes in JSONL without committing (run 'bd sync' later to commit all)") - syncCmd.Flags().Bool("import-only", false, "Only import from JSONL (skip git operations, useful after git pull)") - syncCmd.Flags().Bool("import", false, "Import from JSONL (shorthand for --import-only)") - syncCmd.Flags().Bool("status", false, "Show sync state (pending changes, last export, conflicts)") - syncCmd.Flags().Bool("merge", false, "Merge sync branch back to main branch") - syncCmd.Flags().Bool("from-main", false, "One-way sync from main branch (for ephemeral branches without upstream)") - syncCmd.Flags().Bool("no-git-history", false, "Skip git history backfill for deletions (use during JSONL filename migrations)") - syncCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output sync statistics in JSON format") - syncCmd.Flags().Bool("check", false, "Pre-sync integrity check: detect forced pushes, prefix mismatches, and orphaned issues") - syncCmd.Flags().Bool("accept-rebase", false, "Accept remote sync branch history (use when force-push detected)") - syncCmd.Flags().Bool("full", false, "Full sync: pull → merge → export → commit → push (legacy behavior)") - syncCmd.Flags().Bool("resolve", false, "Resolve pending sync conflicts") - syncCmd.Flags().Bool("ours", false, "Use 'ours' strategy for conflict resolution (with --resolve)") - syncCmd.Flags().Bool("theirs", false, "Use 'theirs' strategy for conflict resolution (with --resolve)") - syncCmd.Flags().Bool("manual", false, "Use interactive manual resolution for conflicts (with --resolve)") - syncCmd.Flags().Bool("force", false, "Force full export/import (skip incremental optimization)") - syncCmd.Flags().String("set-mode", "", "Set sync mode (git-portable, realtime, dolt-native, belt-and-suspenders)") + syncCmd.Flags().Bool("import", false, "Import from JSONL into database") + syncCmd.Flags().Bool("import-only", false, "Import from JSONL into database (alias for --import)") + syncCmd.Flags().Bool("export", false, "Export database to JSONL") + syncCmd.Flags().Bool("flush-only", false, "Export database to JSONL (alias for --export)") + syncCmd.Flags().Bool("pull", false, "Pull from Dolt remote") + syncCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format") rootCmd.AddCommand(syncCmd) } diff --git a/cmd/bd/sync_branch.go b/cmd/bd/sync_branch.go deleted file mode 100644 index 5b70a11a4..000000000 --- a/cmd/bd/sync_branch.go +++ /dev/null @@ -1,358 +0,0 @@ -package main - -import ( - "context" - "fmt" - "os/exec" - "path/filepath" - "strings" - "time" - - "github.com/steveyegge/beads/internal/beads" - "github.com/steveyegge/beads/internal/syncbranch" -) - -// getCurrentBranch returns the name of the current git branch in the beads repo. -// Uses symbolic-ref instead of rev-parse to work in fresh repos without commits (bd-flil) -// GH#1110: Now uses RepoContext to ensure we query the beads repo, not CWD. -// Falls back to CWD-based query if no beads context found (for tests/standalone git). -func getCurrentBranch(ctx context.Context) (string, error) { - var cmd *exec.Cmd - if rc, err := beads.GetRepoContext(); err == nil { - cmd = rc.GitCmd(ctx, "symbolic-ref", "--short", "HEAD") - } else { - // Fallback to CWD for tests or repos without beads - cmd = exec.CommandContext(ctx, "git", "symbolic-ref", "--short", "HEAD") - } - output, err := cmd.Output() - if err != nil { - return "", fmt.Errorf("failed to get current branch: %w", err) - } - return strings.TrimSpace(string(output)), nil -} - -// getCurrentBranchOrHEAD returns the current branch name, or "HEAD" if in detached HEAD state. -// This is useful for jj/jujutsu compatibility where HEAD is always detached but we still -// need a reference for git operations like log and diff. -func getCurrentBranchOrHEAD(ctx context.Context) string { - branch, err := getCurrentBranch(ctx) - if err != nil { - // Detached HEAD - return "HEAD" as the reference - return "HEAD" - } - return branch -} - -// getSyncBranch returns the configured sync branch name -func getSyncBranch(ctx context.Context) (string, error) { - // Ensure store is initialized - if err := ensureStoreActive(); err != nil { - return "", fmt.Errorf("failed to initialize store: %w", err) - } - - syncBranch, err := syncbranch.Get(ctx, store) - if err != nil { - return "", fmt.Errorf("failed to get sync branch config: %w", err) - } - - if syncBranch == "" { - return "", fmt.Errorf("sync.branch not configured (run 'bd config set sync.branch ')") - } - - return syncBranch, nil -} - -// showSyncStatus shows the diff between sync branch and main branch. -// GH#1110: Now uses RepoContext to ensure git commands run in beads repo. -func showSyncStatus(ctx context.Context) error { - if !isGitRepo() { - return fmt.Errorf("not in a git repository") - } - - rc, err := beads.GetRepoContext() - if err != nil { - return fmt.Errorf("failed to get repo context: %w", err) - } - - currentBranch := getCurrentBranchOrHEAD(ctx) - - syncBranch, err := getSyncBranch(ctx) - if err != nil { - return err - } - - // Check if sync branch exists - checkCmd := rc.GitCmd(ctx, "show-ref", "--verify", "--quiet", "refs/heads/"+syncBranch) - if err := checkCmd.Run(); err != nil { - return fmt.Errorf("sync branch '%s' does not exist", syncBranch) - } - - fmt.Printf("Current branch: %s\n", currentBranch) - fmt.Printf("Sync branch: %s\n\n", syncBranch) - - // Show commit diff - fmt.Println("Commits in sync branch not in main:") - logCmd := rc.GitCmd(ctx, "log", "--oneline", currentBranch+".."+syncBranch) - logOutput, err := logCmd.CombinedOutput() - if err != nil { - return fmt.Errorf("failed to get commit log: %w\n%s", err, logOutput) - } - - if len(strings.TrimSpace(string(logOutput))) == 0 { - fmt.Println(" (none)") - } else { - fmt.Print(string(logOutput)) - } - - fmt.Println("\nCommits in main not in sync branch:") - logCmd = rc.GitCmd(ctx, "log", "--oneline", syncBranch+".."+currentBranch) - logOutput, err = logCmd.CombinedOutput() - if err != nil { - return fmt.Errorf("failed to get commit log: %w\n%s", err, logOutput) - } - - if len(strings.TrimSpace(string(logOutput))) == 0 { - fmt.Println(" (none)") - } else { - fmt.Print(string(logOutput)) - } - - // Show file diff for .beads/issues.jsonl - fmt.Println("\nFile differences in .beads/issues.jsonl:") - diffCmd := rc.GitCmd(ctx, "diff", currentBranch+"..."+syncBranch, "--", ".beads/issues.jsonl") - diffOutput, err := diffCmd.CombinedOutput() - if err != nil { - // diff returns non-zero when there are differences, which is fine - if len(diffOutput) == 0 { - return fmt.Errorf("failed to get diff: %w", err) - } - } - - if len(strings.TrimSpace(string(diffOutput))) == 0 { - fmt.Println(" (no differences)") - } else { - fmt.Print(string(diffOutput)) - } - - return nil -} - -// mergeSyncBranch merges the sync branch back to the main branch. -// GH#1110: Now uses RepoContext to ensure git commands run in beads repo. -func mergeSyncBranch(ctx context.Context, dryRun bool) error { - if !isGitRepo() { - return fmt.Errorf("not in a git repository") - } - - rc, err := beads.GetRepoContext() - if err != nil { - return fmt.Errorf("failed to get repo context: %w", err) - } - - currentBranch, err := getCurrentBranch(ctx) - if err != nil { - return err - } - - syncBranch, err := getSyncBranch(ctx) - if err != nil { - return err - } - - // Check if sync branch exists - checkCmd := rc.GitCmd(ctx, "show-ref", "--verify", "--quiet", "refs/heads/"+syncBranch) - if err := checkCmd.Run(); err != nil { - return fmt.Errorf("sync branch '%s' does not exist", syncBranch) - } - - // Check if there are uncommitted changes - statusCmd := rc.GitCmd(ctx, "status", "--porcelain") - statusOutput, err := statusCmd.Output() - if err != nil { - return fmt.Errorf("failed to check git status: %w", err) - } - if len(strings.TrimSpace(string(statusOutput))) > 0 { - return fmt.Errorf("uncommitted changes detected - commit or stash them first") - } - - // GH#1103: Skip-worktree conflict handling removed. - - fmt.Printf("Merging sync branch '%s' into '%s'...\n", syncBranch, currentBranch) - - if dryRun { - fmt.Println("→ [DRY RUN] Would merge sync branch") - // Show what would be merged - logCmd := rc.GitCmd(ctx, "log", "--oneline", currentBranch+".."+syncBranch) - logOutput, _ := logCmd.CombinedOutput() - if len(strings.TrimSpace(string(logOutput))) > 0 { - fmt.Println("\nCommits that would be merged:") - fmt.Print(string(logOutput)) - } else { - fmt.Println("No commits to merge") - } - return nil - } - - // Perform the merge - mergeCmd := rc.GitCmd(ctx, "merge", syncBranch, "-m", fmt.Sprintf("Merge sync branch '%s'", syncBranch)) - mergeOutput, err := mergeCmd.CombinedOutput() - if err != nil { - return fmt.Errorf("merge failed: %w\n%s", err, mergeOutput) - } - - fmt.Print(string(mergeOutput)) - fmt.Println("\n✓ Merge complete") - - // Suggest next steps - fmt.Println("\nNext steps:") - fmt.Println("1. Review the merged changes") - fmt.Println("2. Run 'bd sync --import-only' to sync the database with merged JSONL") - fmt.Println("3. Run 'bd sync' to push changes to remote") - - return nil -} - -// isExternalBeadsDir checks if the beads directory is in a different git repo than cwd. -// This is used to detect when BEADS_DIR points to a separate repository. -// Contributed by dand-oss (https://github.com/steveyegge/beads/pull/533) -// -// GH#810: Use git-common-dir for comparison instead of repo root. -// For bare repo worktrees, GetRepoRoot returns incorrect values, causing -// local worktrees to be incorrectly identified as "external". Using -// git-common-dir correctly identifies that worktrees of the same repo -// share the same git directory. -func isExternalBeadsDir(ctx context.Context, beadsDir string) bool { - // Get git common dir of cwd - cwdCommonDir, err := getGitCommonDir(ctx, ".") - if err != nil { - return false // Can't determine, assume local - } - - // Get git common dir of beads dir - beadsCommonDir, err := getGitCommonDir(ctx, beadsDir) - if err != nil { - return false // Can't determine, assume local - } - - return cwdCommonDir != beadsCommonDir -} - -// getGitCommonDir returns the shared git directory for a path. -// For regular repos, this is the .git directory. -// For worktrees, this returns the shared git directory (common to all worktrees). -// This is the correct way to determine if two paths are in the same git repo, -// especially for bare repos and worktrees. -// GH#810: Added to fix bare repo worktree detection. -func getGitCommonDir(ctx context.Context, path string) (string, error) { - cmd := exec.CommandContext(ctx, "git", "-C", path, "rev-parse", "--git-common-dir") - output, err := cmd.Output() - if err != nil { - return "", fmt.Errorf("failed to get git common dir for %s: %w", path, err) - } - result := strings.TrimSpace(string(output)) - // Make absolute for reliable comparison - if !filepath.IsAbs(result) { - // Resolve the input path to absolute first - absPath, err := filepath.Abs(path) - if err != nil { - return "", fmt.Errorf("failed to get absolute path for %s: %w", path, err) - } - result = filepath.Join(absPath, result) - } - result = filepath.Clean(result) - // Resolve symlinks for consistent comparison (macOS /var -> /private/var) - if resolved, err := filepath.EvalSymlinks(result); err == nil { - result = resolved - } - return result, nil -} - -// getRepoRootFromPath returns the git repository root for a given path. -// Unlike syncbranch.GetRepoRoot which uses cwd, this allows getting the repo root -// for any path. -// Contributed by dand-oss (https://github.com/steveyegge/beads/pull/533) -func getRepoRootFromPath(ctx context.Context, path string) (string, error) { - cmd := exec.CommandContext(ctx, "git", "-C", path, "rev-parse", "--show-toplevel") - output, err := cmd.Output() - if err != nil { - return "", fmt.Errorf("failed to get git root for %s: %w", path, err) - } - return strings.TrimSpace(string(output)), nil -} - -// detectAndClearSkipWorktree and restoreSkipWorktree were removed in GH#1103. - -// commitToExternalBeadsRepo commits changes directly to an external beads repo. -// Used when BEADS_DIR points to a different git repository than cwd. -// This bypasses the worktree-based sync which fails when beads dir is external. -// Contributed by dand-oss (https://github.com/steveyegge/beads/pull/533) -func commitToExternalBeadsRepo(ctx context.Context, beadsDir, message string, push bool) (bool, error) { - repoRoot, err := getRepoRootFromPath(ctx, beadsDir) - if err != nil { - return false, fmt.Errorf("failed to get repo root: %w", err) - } - - // Stage beads files (use relative path from repo root) - relBeadsDir, err := filepath.Rel(repoRoot, beadsDir) - if err != nil { - relBeadsDir = beadsDir // Fallback to absolute path - } - - // Use --sparse to work correctly with sparse-checkout enabled worktrees (fixes #1076) - addCmd := exec.CommandContext(ctx, "git", "-C", repoRoot, "add", "--sparse", relBeadsDir) //nolint:gosec // paths from trusted sources - if output, err := addCmd.CombinedOutput(); err != nil { - return false, fmt.Errorf("git add failed: %w\n%s", err, output) - } - - // Check if there are staged changes - diffCmd := exec.CommandContext(ctx, "git", "-C", repoRoot, "diff", "--cached", "--quiet") //nolint:gosec // repoRoot from git - if diffCmd.Run() == nil { - return false, nil // No changes to commit - } - - // Commit with config-based author and signing options - // Use pathspec to commit ONLY beads files (bd-trgb fix) - // This prevents accidentally committing other staged files - if message == "" { - message = fmt.Sprintf("bd sync: %s", time.Now().Format("2006-01-02 15:04:05")) - } - commitArgs := buildGitCommitArgs(repoRoot, message, "--", relBeadsDir) - commitCmd := exec.CommandContext(ctx, "git", commitArgs...) //nolint:gosec // args from buildGitCommitArgs - if output, err := commitCmd.CombinedOutput(); err != nil { - return false, fmt.Errorf("git commit failed: %w\n%s", err, output) - } - - // Push if requested - if push { - pushCmd := exec.CommandContext(ctx, "git", "-C", repoRoot, "push") //nolint:gosec // repoRoot from git - if pushOutput, err := runGitCmdWithTimeoutMsg(ctx, pushCmd, "git push", 5*time.Second); err != nil { - return true, fmt.Errorf("git push failed: %w\n%s", err, pushOutput) - } - } - - return true, nil -} - -// pullFromExternalBeadsRepo pulls changes in an external beads repo. -// Used when BEADS_DIR points to a different git repository than cwd. -// Contributed by dand-oss (https://github.com/steveyegge/beads/pull/533) -func pullFromExternalBeadsRepo(ctx context.Context, beadsDir string) error { - repoRoot, err := getRepoRootFromPath(ctx, beadsDir) - if err != nil { - return fmt.Errorf("failed to get repo root: %w", err) - } - - // Check if remote exists - remoteCmd := exec.CommandContext(ctx, "git", "-C", repoRoot, "remote") //nolint:gosec // repoRoot from git - remoteOutput, err := remoteCmd.Output() - if err != nil || len(strings.TrimSpace(string(remoteOutput))) == 0 { - return nil // No remote, skip pull - } - - pullCmd := exec.CommandContext(ctx, "git", "-C", repoRoot, "pull") //nolint:gosec // repoRoot from git - if output, err := pullCmd.CombinedOutput(); err != nil { - return fmt.Errorf("git pull failed: %w\n%s", err, output) - } - - return nil -} diff --git a/cmd/bd/sync_branch_priority_test.go b/cmd/bd/sync_branch_priority_test.go deleted file mode 100644 index b23f49864..000000000 --- a/cmd/bd/sync_branch_priority_test.go +++ /dev/null @@ -1,253 +0,0 @@ -//go:build cgo - -package main - -import ( - "context" - "os" - "os/exec" - "path/filepath" - "testing" - - "github.com/steveyegge/beads/internal/storage/dolt" - "github.com/steveyegge/beads/internal/syncbranch" -) - -// TestSyncBranchConfigPriorityOverUpstream tests that when sync.branch is configured, -// bd sync should NOT fall back to --from-main mode even if the current branch has no upstream. -// This is the regression test for GH#638. -func TestSyncBranchConfigPriorityOverUpstream(t *testing.T) { - if testing.Short() { - t.Skip("Skipping integration test in short mode") - } - - ctx := context.Background() - - t.Run("sync.branch configured without upstream should not fallback to from-main", func(t *testing.T) { - // Setup: Create a git repo with no upstream tracking - tmpDir, cleanup := setupGitRepo(t) - defer cleanup() - - // Create beads database and configure sync.branch - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0750); err != nil { - t.Fatalf("Failed to create .beads dir: %v", err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("Failed to create test database: %v", err) - } - defer testStore.Close() - - // Configure sync.branch - if err := syncbranch.Set(ctx, testStore, "beads-sync"); err != nil { - t.Fatalf("Failed to set sync.branch: %v", err) - } - - // Verify sync.branch is configured - syncBranch, err := syncbranch.Get(ctx, testStore) - if err != nil { - t.Fatalf("Failed to get sync.branch: %v", err) - } - if syncBranch != "beads-sync" { - t.Errorf("Expected sync.branch='beads-sync', got %q", syncBranch) - } - - // Verify we have no upstream - if gitHasUpstream() { - t.Skip("Test requires no upstream tracking") - } - - // The key assertion: hasSyncBranchConfig should be true - // which prevents fallback to from-main mode - var hasSyncBranchConfig bool - if syncBranch != "" { - hasSyncBranchConfig = true - } - - if !hasSyncBranchConfig { - t.Error("hasSyncBranchConfig should be true when sync.branch is configured") - } - - // With the fix, this condition should be false (should NOT fallback) - shouldFallbackToFromMain := !gitHasUpstream() && !hasSyncBranchConfig - if shouldFallbackToFromMain { - t.Error("Should NOT fallback to from-main when sync.branch is configured") - } - }) - - t.Run("no sync.branch and no upstream should fallback to from-main", func(t *testing.T) { - // Setup: Create a git repo with no upstream tracking - _, cleanup := setupGitRepo(t) - defer cleanup() - - // No sync.branch configured, no upstream - hasSyncBranchConfig := false - - // Verify we have no upstream - if gitHasUpstream() { - t.Skip("Test requires no upstream tracking") - } - - // With no sync.branch, should fallback to from-main - shouldFallbackToFromMain := !gitHasUpstream() && !hasSyncBranchConfig - if !shouldFallbackToFromMain { - t.Error("Should fallback to from-main when no sync.branch and no upstream") - } - }) - - t.Run("detached HEAD with sync.branch should not fallback", func(t *testing.T) { - // Setup: Create a git repo and detach HEAD (simulating jj workflow) - tmpDir, cleanup := setupGitRepo(t) - defer cleanup() - - // Get current commit hash - cmd := exec.Command("git", "rev-parse", "HEAD") - output, err := cmd.Output() - if err != nil { - t.Fatalf("Failed to get HEAD: %v", err) - } - commitHash := string(output[:len(output)-1]) // trim newline - - // Detach HEAD - cmd = exec.Command("git", "checkout", "--detach", commitHash) - if err := cmd.Run(); err != nil { - t.Fatalf("Failed to detach HEAD: %v", err) - } - - // Create beads database and configure sync.branch - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0750); err != nil { - t.Fatalf("Failed to create .beads dir: %v", err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("Failed to create test database: %v", err) - } - defer testStore.Close() - - // Configure sync.branch - if err := syncbranch.Set(ctx, testStore, "beads-sync"); err != nil { - t.Fatalf("Failed to set sync.branch: %v", err) - } - - // Verify detached HEAD has no upstream - if gitHasUpstream() { - t.Error("Detached HEAD should not have upstream") - } - - // With sync.branch configured, should NOT fallback - hasSyncBranchConfig := true - shouldFallbackToFromMain := !gitHasUpstream() && !hasSyncBranchConfig - if shouldFallbackToFromMain { - t.Error("Detached HEAD with sync.branch should NOT fallback to from-main") - } - }) -} - -// TestSyncBranchBypassesGitHasBeadsChanges tests that when sync.branch is configured, -// bd sync bypasses gitHasBeadsChanges and always calls CommitToSyncBranch. -// This is the regression test for GH#812: when .beads/ is gitignored on code branches -// (but tracked on the sync branch), gitHasBeadsChanges would return false, causing -// sync to skip CommitToSyncBranch entirely - even though CommitToSyncBranch has its -// own internal change detection that checks the worktree where gitignore is different. -func TestSyncBranchBypassesGitHasBeadsChanges(t *testing.T) { - if testing.Short() { - t.Skip("Skipping integration test in short mode") - } - - ctx := context.Background() - - t.Run("CommitToSyncBranch detects changes even when main repo has gitignored beads", func(t *testing.T) { - // Setup: Create a git repo with sync-branch configured - tmpDir, cleanup := setupGitRepo(t) - defer cleanup() - - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0750); err != nil { - t.Fatalf("Failed to create .beads dir: %v", err) - } - - // Create a sync branch with initial content - syncBranch := "beads-sync" - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - - // Write initial content - if err := os.WriteFile(jsonlPath, []byte(`{"id":"test-1","title":"Initial"}`+"\n"), 0600); err != nil { - t.Fatalf("Failed to write initial JSONL: %v", err) - } - - // Create sync branch and commit the initial content - if err := exec.Command("git", "checkout", "-b", syncBranch).Run(); err != nil { - t.Fatalf("Failed to create sync branch: %v", err) - } - if err := exec.Command("git", "add", ".").Run(); err != nil { - t.Fatalf("Failed to add files: %v", err) - } - if err := exec.Command("git", "commit", "-m", "initial sync").Run(); err != nil { - t.Fatalf("Failed to commit: %v", err) - } - if err := exec.Command("git", "checkout", "main").Run(); err != nil { - t.Fatalf("Failed to checkout main: %v", err) - } - - // Recreate .beads directory on main branch (it may not exist after checkout) - if err := os.MkdirAll(beadsDir, 0750); err != nil { - t.Fatalf("Failed to recreate .beads dir: %v", err) - } - - // Now add a gitignore that ignores all beads files on the code branch - // (simulating the pattern from GH#812) - gitignorePath := filepath.Join(beadsDir, ".gitignore") - gitignoreContent := `# On code branches, ignore all data files. -# The beads-sync branch tracks issues.jsonl, etc. -* -!.gitignore -` - if err := os.WriteFile(gitignorePath, []byte(gitignoreContent), 0600); err != nil { - t.Fatalf("Failed to write .gitignore: %v", err) - } - if err := exec.Command("git", "add", gitignorePath).Run(); err != nil { - t.Fatalf("Failed to add .gitignore: %v", err) - } - if err := exec.Command("git", "commit", "-m", "add gitignore").Run(); err != nil { - t.Fatalf("Failed to commit .gitignore: %v", err) - } - - // Now update the JSONL file (this change is gitignored on main branch) - newContent := `{"id":"test-1","title":"Initial"}` + "\n" + `{"id":"test-2","title":"New issue"}` + "\n" - if err := os.WriteFile(jsonlPath, []byte(newContent), 0600); err != nil { - t.Fatalf("Failed to update JSONL: %v", err) - } - - // Verify gitHasBeadsChanges returns false (file is gitignored) - hasChanges, err := gitHasBeadsChanges(ctx) - if err != nil { - t.Fatalf("gitHasBeadsChanges error: %v", err) - } - if hasChanges { - t.Log("Note: gitHasBeadsChanges returned true (gitignore may not be working as expected in test env)") - // Continue test anyway - the key assertion is that CommitToSyncBranch works - } else { - t.Log("gitHasBeadsChanges correctly returned false (file is gitignored)") - } - - // The key assertion: CommitToSyncBranch should still detect and commit changes - // because it checks the worktree where the gitignore is different - result, err := syncbranch.CommitToSyncBranch(ctx, tmpDir, syncBranch, jsonlPath, false) - if err != nil { - t.Fatalf("CommitToSyncBranch error: %v", err) - } - - if !result.Committed { - t.Error("CommitToSyncBranch() Committed = false, want true") - t.Error("This indicates the GH#812 fix regression: sync branch worktree should detect changes even when main repo has files gitignored") - } else { - t.Log("CommitToSyncBranch correctly detected and committed changes to worktree") - } - }) -} diff --git a/cmd/bd/sync_bridge.go b/cmd/bd/sync_bridge.go deleted file mode 100644 index a5fb8dccb..000000000 --- a/cmd/bd/sync_bridge.go +++ /dev/null @@ -1,248 +0,0 @@ -package main - -import ( - "bufio" - "context" - "encoding/json" - "fmt" - "log/slog" - "os" - - "github.com/steveyegge/beads/internal/config" - "github.com/steveyegge/beads/internal/types" - "github.com/steveyegge/beads/internal/validation" -) - -// resolveNoGitHistoryForFromMain returns the effective noGitHistory flag. -// When fromMain is true, noGitHistory defaults to true (fixes #417). -func resolveNoGitHistoryForFromMain(fromMain, noGitHistory bool) bool { - if fromMain && !noGitHistory { - return true - } - return noGitHistory -} - -// exportToJSONL exports the current database state to the JSONL file. -// Delegates to exportToJSONLWithStore using the global store. -func exportToJSONL(ctx context.Context, jsonlPath string) error { - if err := ensureStoreActive(); err != nil { - return fmt.Errorf("activating store: %w", err) - } - if err := exportToJSONLWithStore(ctx, store, jsonlPath); err != nil { - return err - } - // Update content hash metadata after successful export - repoKey := getRepoKeyForPath(jsonlPath) - updateExportMetadata(ctx, store, jsonlPath, slog.Default(), repoKey) - return nil -} - -// importFromJSONL imports issues from a JSONL file into the database. -// Parameters renameOnImport and noGitHistory are accepted for API compatibility -// but are no longer used in the Dolt-only world. -func importFromJSONL(ctx context.Context, jsonlPath string, _, _ bool) error { - if err := ensureStoreActive(); err != nil { - return fmt.Errorf("activating store: %w", err) - } - return importToJSONLWithStore(ctx, store, jsonlPath) -} - -// importFromJSONLInline imports issues from JSONL inline (without subprocess). -// This was the inline variant of importFromJSONL to avoid subprocess path resolution -// issues. In the Dolt-only world, both functions are equivalent. -func importFromJSONLInline(ctx context.Context, jsonlPath string, renameOnImport, noGitHistory, _ bool) error { - return importFromJSONL(ctx, jsonlPath, renameOnImport, noGitHistory) -} - -// loadIssuesFromJSONL reads a JSONL file and returns the parsed issues. -func loadIssuesFromJSONL(jsonlPath string) ([]*types.Issue, error) { - file, err := os.Open(jsonlPath) // #nosec G304 - controlled path - if err != nil { - if os.IsNotExist(err) { - return nil, nil - } - return nil, fmt.Errorf("opening JSONL: %w", err) - } - defer file.Close() - - var issues []*types.Issue - scanner := bufio.NewScanner(file) - const maxScannerBuffer = 1024 * 1024 // 1MB - scanner.Buffer(make([]byte, 0, maxScannerBuffer), maxScannerBuffer) - - lineNum := 0 - for scanner.Scan() { - lineNum++ - line := scanner.Text() - if line == "" { - continue - } - - var issue types.Issue - if err := json.Unmarshal([]byte(line), &issue); err != nil { - fmt.Fprintf(os.Stderr, "Warning: failed to parse JSONL line %d: %v\n", lineNum, err) - continue - } - issues = append(issues, &issue) - } - - if err := scanner.Err(); err != nil { - return nil, fmt.Errorf("reading JSONL: %w", err) - } - - return issues, nil -} - -// doSyncFromMain performs a one-way sync from the main branch. -// Reads the JSONL from main and imports it into the current database. -func doSyncFromMain(ctx context.Context, jsonlPath string, renameOnImport, dryRun, noGitHistory bool) error { - if dryRun { - fmt.Println("→ [DRY RUN] Would sync from main branch") - return nil - } - - // Read JSONL from main branch via git - relPath, err := getRelativeGitPath(jsonlPath) - if err != nil { - return fmt.Errorf("getting relative path: %w", err) - } - - mainData, err := readFromGitRef(relPath, "main") - if err != nil { - // Try "master" as fallback - mainData, err = readFromGitRef(relPath, "master") - if err != nil { - return fmt.Errorf("reading JSONL from main branch: %w", err) - } - } - - // Write main branch content to a temp file for import - tmpFile, err := os.CreateTemp("", "bd-sync-from-main-*.jsonl") - if err != nil { - return fmt.Errorf("creating temp file: %w", err) - } - tmpPath := tmpFile.Name() - defer os.Remove(tmpPath) - - if _, err := tmpFile.Write(mainData); err != nil { - tmpFile.Close() - return fmt.Errorf("writing temp file: %w", err) - } - tmpFile.Close() - - // Import from the temp file - fmt.Println("→ Importing from main branch...") - if err := importFromJSONL(ctx, tmpPath, renameOnImport, noGitHistory); err != nil { - return fmt.Errorf("importing from main: %w", err) - } - - // Export back to update local JSONL - fmt.Println("→ Exporting to JSONL...") - if err := exportToJSONL(ctx, jsonlPath); err != nil { - return fmt.Errorf("exporting: %w", err) - } - - fmt.Println("✓ Synced from main branch") - return nil -} - -// getRelativeGitPath converts an absolute path to a git-relative path. -func getRelativeGitPath(absPath string) (string, error) { - // Use the beads dir to find the git root - beadsDir := findJSONLPath() - if beadsDir == "" { - return absPath, nil // fallback - } - // Git show needs repo-relative paths - // Simple approach: try the path as-is and let git figure it out - return absPath, nil -} - -// ExportResult describes the outcome of an incremental export operation. -type ExportResult struct { - ExportedIDs []string -} - -// exportToJSONLIncrementalDeferred performs an export and returns the result. -// In the Dolt-only world, this delegates to the standard export. -func exportToJSONLIncrementalDeferred(ctx context.Context, jsonlPath string) (*ExportResult, error) { - if err := ensureStoreActive(); err != nil { - return nil, fmt.Errorf("activating store: %w", err) - } - - // Get all issues for the result - issues, err := store.SearchIssues(ctx, "", types.IssueFilter{}) - if err != nil { - return nil, fmt.Errorf("getting issues: %w", err) - } - - // Perform the export - if err := exportToJSONLWithStore(ctx, store, jsonlPath); err != nil { - return nil, err - } - - // Build result - result := &ExportResult{ - ExportedIDs: make([]string, 0, len(issues)), - } - for _, issue := range issues { - result.ExportedIDs = append(result.ExportedIDs, issue.ID) - } - - return result, nil -} - -// validateOpenIssuesForSync checks that open issues pass template validation before sync. -// Controlled by the "validation.on-sync" config key: -// - "none" or "": skip validation (default) -// - "warn": validate and warn but don't block -// - "error": validate and block sync if issues fail -func validateOpenIssuesForSync(ctx context.Context) error { - mode := config.GetString("validation.on-sync") - if mode == "" || mode == "none" { - return nil - } - - if err := ensureStoreActive(); err != nil { - return nil // Can't validate without store, skip - } - - openStatus := types.StatusOpen - issues, err := store.SearchIssues(ctx, "", types.IssueFilter{Status: &openStatus}) - if err != nil { - return nil // Skip validation on error - } - - var invalidCount int - for _, issue := range issues { - // Skip chores - they don't have required sections - if issue.IssueType == types.TypeChore { - continue - } - if err := validation.ValidateTemplate(issue.IssueType, issue.Description); err != nil { - invalidCount++ - if mode == "warn" || mode == "error" { - fmt.Fprintf(os.Stderr, "Warning: %s fails template validation: %v\n", issue.ID, err) - } - } - } - - if invalidCount > 0 && mode == "error" { - return fmt.Errorf("%d open issue(s) fail template validation (set validation.on-sync=warn to allow)", invalidCount) - } - - return nil -} - -// finalizeExport updates metadata after a successful export. -func finalizeExport(ctx context.Context, result *ExportResult) { - if result == nil || store == nil { - return - } - jsonlPath := findJSONLPath() - if jsonlPath == "" { - return - } - repoKey := getRepoKeyForPath(jsonlPath) - updateExportMetadata(ctx, store, jsonlPath, slog.Default(), repoKey) -} diff --git a/cmd/bd/sync_check.go b/cmd/bd/sync_check.go deleted file mode 100644 index b94057db4..000000000 --- a/cmd/bd/sync_check.go +++ /dev/null @@ -1,397 +0,0 @@ -package main - -import ( - "bufio" - "bytes" - "context" - "encoding/json" - "fmt" - "os" - "os/exec" - "strings" - "time" - - "github.com/steveyegge/beads/internal/beads" - "github.com/steveyegge/beads/internal/syncbranch" -) - -// SyncIntegrityResult contains the results of a pre-sync integrity check. -type SyncIntegrityResult struct { - ForcedPush *ForcedPushCheck `json:"forced_push,omitempty"` - PrefixMismatch *PrefixMismatch `json:"prefix_mismatch,omitempty"` - OrphanedChildren *OrphanedChildren `json:"orphaned_children,omitempty"` - HasProblems bool `json:"has_problems"` -} - -// ForcedPushCheck detects if sync branch has diverged from remote. -type ForcedPushCheck struct { - Detected bool `json:"detected"` - LocalRef string `json:"local_ref,omitempty"` - RemoteRef string `json:"remote_ref,omitempty"` - Message string `json:"message"` -} - -// PrefixMismatch detects issues with wrong prefix in JSONL. -type PrefixMismatch struct { - ConfiguredPrefix string `json:"configured_prefix"` - MismatchedIDs []string `json:"mismatched_ids,omitempty"` - Count int `json:"count"` -} - -// OrphanedChildren detects issues with parent that doesn't exist. -type OrphanedChildren struct { - OrphanedIDs []string `json:"orphaned_ids,omitempty"` - Count int `json:"count"` -} - -// showSyncIntegrityCheck performs pre-sync integrity checks without modifying state. -// Detects forced pushes, prefix mismatches, and orphaned children. -// Exits with code 1 if problems are detected. -func showSyncIntegrityCheck(ctx context.Context, jsonlPath string) { - fmt.Println("Sync Integrity Check") - fmt.Println("====================") - - result := &SyncIntegrityResult{} - - // Check 1: Detect forced pushes on sync branch - forcedPush := checkForcedPush(ctx) - result.ForcedPush = forcedPush - if forcedPush.Detected { - result.HasProblems = true - } - printForcedPushResult(forcedPush) - - // Check 2: Detect prefix mismatches in JSONL - prefixMismatch, err := checkPrefixMismatch(ctx, jsonlPath) - if err != nil { - fmt.Fprintf(os.Stderr, "Warning: prefix check failed: %v\n", err) - } else { - result.PrefixMismatch = prefixMismatch - if prefixMismatch != nil && prefixMismatch.Count > 0 { - result.HasProblems = true - } - printPrefixMismatchResult(prefixMismatch) - } - - // Check 3: Detect orphaned children (parent issues that don't exist) - orphaned, err := checkOrphanedChildrenInJSONL(jsonlPath) - if err != nil { - fmt.Fprintf(os.Stderr, "Warning: orphaned check failed: %v\n", err) - } else { - result.OrphanedChildren = orphaned - if orphaned != nil && orphaned.Count > 0 { - result.HasProblems = true - } - printOrphanedChildrenResult(orphaned) - } - - // Summary - fmt.Println("\nSummary") - fmt.Println("-------") - if result.HasProblems { - fmt.Println("Problems detected! Review above and consider:") - if result.ForcedPush != nil && result.ForcedPush.Detected { - fmt.Println(" - Force push: Reset local sync branch or use 'bd sync --from-main'") - } - if result.PrefixMismatch != nil && result.PrefixMismatch.Count > 0 { - fmt.Println(" - Prefix mismatch: Use 'bd import --rename-on-import' to fix") - } - if result.OrphanedChildren != nil && result.OrphanedChildren.Count > 0 { - fmt.Println(" - Orphaned children: Remove parent references or create missing parents") - } - os.Exit(1) - } else { - fmt.Println("No problems detected. Safe to sync.") - } - - if jsonOutput { - data, _ := json.MarshalIndent(result, "", " ") // json.MarshalIndent on simple structs does not fail in practice - fmt.Println(string(data)) - } -} - -// checkForcedPush detects if the sync branch has diverged from remote. -// This can happen when someone force-pushes to the sync branch. -// GH#1110: Now uses RepoContext to ensure git commands run in beads repo. -func checkForcedPush(ctx context.Context) *ForcedPushCheck { - result := &ForcedPushCheck{ - Detected: false, - Message: "No sync branch configured or no remote", - } - - // Get RepoContext for beads repo - rc, err := beads.GetRepoContext() - if err != nil { - result.Message = fmt.Sprintf("Failed to get repo context: %v", err) - return result - } - - // Get sync branch name - if err := ensureStoreActive(); err != nil { - return result - } - - syncBranch, _ := syncbranch.Get(ctx, store) // Best effort: empty syncBranch means feature not configured - if syncBranch == "" { - return result - } - - // Check if sync branch exists locally - checkLocalCmd := rc.GitCmd(ctx, "show-ref", "--verify", "--quiet", "refs/heads/"+syncBranch) - if checkLocalCmd.Run() != nil { - result.Message = fmt.Sprintf("Sync branch '%s' does not exist locally", syncBranch) - return result - } - - // Get local ref - localRefCmd := rc.GitCmd(ctx, "rev-parse", syncBranch) - localRefOutput, err := localRefCmd.Output() - if err != nil { - result.Message = "Failed to get local sync branch ref" - return result - } - localRef := strings.TrimSpace(string(localRefOutput)) - result.LocalRef = localRef - - // Check if remote tracking branch exists - remote := "origin" - if configuredRemote, err := store.GetConfig(ctx, "sync.remote"); err == nil && configuredRemote != "" { - remote = configuredRemote - } - - // Get remote ref - remoteRefCmd := rc.GitCmd(ctx, "rev-parse", remote+"/"+syncBranch) - remoteRefOutput, err := remoteRefCmd.Output() - if err != nil { - result.Message = fmt.Sprintf("Remote tracking branch '%s/%s' does not exist", remote, syncBranch) - return result - } - remoteRef := strings.TrimSpace(string(remoteRefOutput)) - result.RemoteRef = remoteRef - - // If refs match, no divergence - if localRef == remoteRef { - result.Message = "Sync branch is in sync with remote" - return result - } - - // Check if local is ahead of remote (normal case) - aheadCmd := rc.GitCmd(ctx, "merge-base", "--is-ancestor", remoteRef, localRef) - if aheadCmd.Run() == nil { - result.Message = "Local sync branch is ahead of remote (normal)" - return result - } - - // Check if remote is ahead of local (behind, needs pull) - behindCmd := rc.GitCmd(ctx, "merge-base", "--is-ancestor", localRef, remoteRef) - if behindCmd.Run() == nil { - result.Message = "Local sync branch is behind remote (needs pull)" - return result - } - - // If neither is ancestor, branches have diverged - likely a force push - result.Detected = true - result.Message = fmt.Sprintf("Sync branch has DIVERGED from remote! Local: %s, Remote: %s. This may indicate a force push on the remote.", localRef[:8], remoteRef[:8]) - - return result -} - -func printForcedPushResult(fp *ForcedPushCheck) { - fmt.Println("1. Force Push Detection") - if fp.Detected { - fmt.Printf(" [PROBLEM] %s\n", fp.Message) - } else { - fmt.Printf(" [OK] %s\n", fp.Message) - } - fmt.Println() -} - -// checkPrefixMismatch detects issues in JSONL that don't match the configured prefix. -func checkPrefixMismatch(ctx context.Context, jsonlPath string) (*PrefixMismatch, error) { - result := &PrefixMismatch{ - MismatchedIDs: []string{}, - } - - // Get configured prefix - if err := ensureStoreActive(); err != nil { - return nil, err - } - - prefix, err := store.GetConfig(ctx, "issue_prefix") - if err != nil || prefix == "" { - prefix = "bd" // Default - } - result.ConfiguredPrefix = prefix - - // Read JSONL and check each issue's prefix - f, err := os.Open(jsonlPath) // #nosec G304 - controlled path - if err != nil { - if os.IsNotExist(err) { - return result, nil // No JSONL, no mismatches - } - return nil, fmt.Errorf("failed to open JSONL: %w", err) - } - defer f.Close() - - scanner := bufio.NewScanner(f) - scanner.Buffer(make([]byte, 0, 64*1024), 10*1024*1024) - - for scanner.Scan() { - line := scanner.Bytes() - if len(bytes.TrimSpace(line)) == 0 { - continue - } - - var issue struct { - ID string `json:"id"` - } - if err := json.Unmarshal(line, &issue); err != nil { - continue // Skip malformed lines - } - - // Check if ID starts with configured prefix - if !strings.HasPrefix(issue.ID, prefix+"-") { - result.MismatchedIDs = append(result.MismatchedIDs, issue.ID) - } - } - - if err := scanner.Err(); err != nil { - return nil, fmt.Errorf("failed to read JSONL: %w", err) - } - - result.Count = len(result.MismatchedIDs) - return result, nil -} - -func printPrefixMismatchResult(pm *PrefixMismatch) { - fmt.Println("2. Prefix Mismatch Check") - if pm == nil { - fmt.Println(" [SKIP] Could not check prefix") - fmt.Println() - return - } - - fmt.Printf(" Configured prefix: %s\n", pm.ConfiguredPrefix) - if pm.Count > 0 { - fmt.Printf(" [PROBLEM] Found %d issue(s) with wrong prefix:\n", pm.Count) - // Show first 10 - limit := pm.Count - if limit > 10 { - limit = 10 - } - for i := 0; i < limit; i++ { - fmt.Printf(" - %s\n", pm.MismatchedIDs[i]) - } - if pm.Count > 10 { - fmt.Printf(" ... and %d more\n", pm.Count-10) - } - } else { - fmt.Println(" [OK] All issues have correct prefix") - } - fmt.Println() -} - -// checkOrphanedChildrenInJSONL detects issues with parent references to non-existent issues. -func checkOrphanedChildrenInJSONL(jsonlPath string) (*OrphanedChildren, error) { - result := &OrphanedChildren{ - OrphanedIDs: []string{}, - } - - // Read JSONL and build maps of IDs and parent references - f, err := os.Open(jsonlPath) // #nosec G304 - controlled path - if err != nil { - if os.IsNotExist(err) { - return result, nil - } - return nil, fmt.Errorf("failed to open JSONL: %w", err) - } - defer f.Close() - - existingIDs := make(map[string]bool) - parentRefs := make(map[string]string) // child ID -> parent ID - - scanner := bufio.NewScanner(f) - scanner.Buffer(make([]byte, 0, 64*1024), 10*1024*1024) - - for scanner.Scan() { - line := scanner.Bytes() - if len(bytes.TrimSpace(line)) == 0 { - continue - } - - var issue struct { - ID string `json:"id"` - Parent string `json:"parent,omitempty"` - Status string `json:"status"` - } - if err := json.Unmarshal(line, &issue); err != nil { - continue - } - - existingIDs[issue.ID] = true - if issue.Parent != "" { - parentRefs[issue.ID] = issue.Parent - } - } - - if err := scanner.Err(); err != nil { - return nil, fmt.Errorf("failed to read JSONL: %w", err) - } - - // Find orphaned children (parent doesn't exist) - for childID, parentID := range parentRefs { - if !existingIDs[parentID] { - result.OrphanedIDs = append(result.OrphanedIDs, fmt.Sprintf("%s (parent: %s)", childID, parentID)) - } - } - - result.Count = len(result.OrphanedIDs) - return result, nil -} - -// runGitCmdWithTimeoutMsg runs a git command and prints a helpful message if it takes too long. -// This helps when git operations hang waiting for credential/browser auth. -func runGitCmdWithTimeoutMsg(ctx context.Context, cmd *exec.Cmd, cmdName string, timeoutDelay time.Duration) ([]byte, error) { - // Use done channel to cleanly exit goroutine when command completes - done := make(chan struct{}) - go func() { - select { - case <-time.After(timeoutDelay): - fmt.Fprintf(os.Stderr, "⏳ %s is taking longer than expected (possibly waiting for authentication). If this hangs, check for a browser auth prompt or run 'git status' in another terminal.\n", cmdName) - case <-done: - // Command completed, exit cleanly - case <-ctx.Done(): - // Context canceled, don't print message - } - }() - - output, err := cmd.CombinedOutput() - close(done) - return output, err -} - -func printOrphanedChildrenResult(oc *OrphanedChildren) { - fmt.Println("3. Orphaned Children Check") - if oc == nil { - fmt.Println(" [SKIP] Could not check orphaned children") - fmt.Println() - return - } - - if oc.Count > 0 { - fmt.Printf(" [PROBLEM] Found %d issue(s) with missing parent:\n", oc.Count) - limit := oc.Count - if limit > 10 { - limit = 10 - } - for i := 0; i < limit; i++ { - fmt.Printf(" - %s\n", oc.OrphanedIDs[i]) - } - if oc.Count > 10 { - fmt.Printf(" ... and %d more\n", oc.Count-10) - } - } else { - fmt.Println(" [OK] No orphaned children found") - } - fmt.Println() -} diff --git a/cmd/bd/sync_conflict.go b/cmd/bd/sync_conflict.go deleted file mode 100644 index 5c7e5a60d..000000000 --- a/cmd/bd/sync_conflict.go +++ /dev/null @@ -1,354 +0,0 @@ -package main - -import ( - "context" - "encoding/json" - "fmt" - "os" - "path/filepath" - - "github.com/steveyegge/beads/internal/beads" - "github.com/steveyegge/beads/internal/config" -) - -// SyncConflictState tracks pending sync conflicts. -type SyncConflictState struct { - Conflicts []SyncConflictRecord `json:"conflicts,omitempty"` -} - -// SyncConflictRecord represents a conflict detected during sync. -type SyncConflictRecord struct { - IssueID string `json:"issue_id"` - Reason string `json:"reason"` - LocalVersion string `json:"local_version,omitempty"` - RemoteVersion string `json:"remote_version,omitempty"` - Strategy string `json:"strategy,omitempty"` // how it was resolved -} - -// LoadSyncConflictState loads the sync conflict state from disk. -func LoadSyncConflictState(beadsDir string) (*SyncConflictState, error) { - path := filepath.Join(beadsDir, "sync_conflicts.json") - // #nosec G304 -- path is derived from the workspace .beads directory - data, err := os.ReadFile(path) - if err != nil { - if os.IsNotExist(err) { - return &SyncConflictState{}, nil - } - return nil, err - } - - var state SyncConflictState - if err := json.Unmarshal(data, &state); err != nil { - return nil, err - } - return &state, nil -} - -// SaveSyncConflictState saves the sync conflict state to disk. -func SaveSyncConflictState(beadsDir string, state *SyncConflictState) error { - path := filepath.Join(beadsDir, "sync_conflicts.json") - data, err := json.MarshalIndent(state, "", " ") - if err != nil { - return err - } - return os.WriteFile(path, data, 0600) -} - -// ClearSyncConflictState removes the sync conflict state file. -func ClearSyncConflictState(beadsDir string) error { - path := filepath.Join(beadsDir, "sync_conflicts.json") - if err := os.Remove(path); err != nil && !os.IsNotExist(err) { - return err - } - return nil -} - -// resolveSyncConflicts resolves pending sync conflicts using the specified strategy. -// Strategies: -// - "newest": Keep whichever version has the newer updated_at timestamp (default) -// - "ours": Keep local version -// - "theirs": Keep remote version -// - "manual": Interactive resolution with user prompts -func resolveSyncConflicts(ctx context.Context, jsonlPath string, strategy config.ConflictStrategy, dryRun bool) error { - beadsDir := filepath.Dir(jsonlPath) - - conflictState, err := LoadSyncConflictState(beadsDir) - if err != nil { - return fmt.Errorf("loading sync conflicts: %w", err) - } - - if len(conflictState.Conflicts) == 0 { - fmt.Println("No conflicts to resolve") - return nil - } - - if dryRun { - fmt.Printf("→ [DRY RUN] Would resolve %d conflicts using '%s' strategy\n", len(conflictState.Conflicts), strategy) - for _, c := range conflictState.Conflicts { - fmt.Printf(" - %s: %s\n", c.IssueID, c.Reason) - } - return nil - } - - fmt.Printf("Resolving conflicts using '%s' strategy...\n", strategy) - - // Load base, local, and remote states for merge - baseIssues, err := loadBaseState(beadsDir) - if err != nil { - return fmt.Errorf("loading base state: %w", err) - } - - if err := ensureStoreActive(); err != nil { - return fmt.Errorf("initializing store: %w", err) - } - - localIssues, err := store.SearchIssues(ctx, "", beads.IssueFilter{}) - if err != nil { - return fmt.Errorf("loading local issues: %w", err) - } - - remoteIssues, err := loadIssuesFromJSONL(jsonlPath) - if err != nil { - return fmt.Errorf("loading remote issues: %w", err) - } - - // Build maps for quick lookup - baseMap := make(map[string]*beads.Issue) - for _, issue := range baseIssues { - baseMap[issue.ID] = issue - } - localMap := make(map[string]*beads.Issue) - for _, issue := range localIssues { - localMap[issue.ID] = issue - } - remoteMap := make(map[string]*beads.Issue) - for _, issue := range remoteIssues { - remoteMap[issue.ID] = issue - } - - // Handle manual strategy with interactive resolution - if strategy == config.ConflictStrategyManual { - return resolveSyncConflictsManually(ctx, jsonlPath, beadsDir, conflictState, baseMap, localMap, remoteMap) - } - - // Determine winner for each conflict based on strategy - winners := make(map[string]*beads.Issue) // issueID -> winning version - resolved := 0 - for _, conflict := range conflictState.Conflicts { - local := localMap[conflict.IssueID] - remote := remoteMap[conflict.IssueID] - - var winner string - switch strategy { - case config.ConflictStrategyOurs: - winner = "local" - case config.ConflictStrategyTheirs: - winner = "remote" - case config.ConflictStrategyNewest: - fallthrough - default: - // Compare updated_at timestamps - if local != nil && remote != nil { - if local.UpdatedAt.After(remote.UpdatedAt) { - winner = "local" - } else { - winner = "remote" - } - } else if local != nil { - winner = "local" - } else { - winner = "remote" - } - } - - // Store the winning version - if winner == "local" && local != nil { - winners[conflict.IssueID] = local - } else if remote != nil { - winners[conflict.IssueID] = remote - } - - fmt.Printf("✓ %s: kept %s", conflict.IssueID, winner) - if strategy == config.ConflictStrategyNewest { - fmt.Print(" (newer)") - } - fmt.Println() - resolved++ - } - - // Clear conflicts after resolution - if err := ClearSyncConflictState(beadsDir); err != nil { - return fmt.Errorf("clearing conflict state: %w", err) - } - - // Run merge for non-conflicting issues, then override conflicts with chosen winners - mergeResult := MergeIssues(baseIssues, localIssues, remoteIssues) - - // Override conflicting issues with the strategy-chosen winner - for i, issue := range mergeResult.Merged { - if winner, ok := winners[issue.ID]; ok { - mergeResult.Merged[i] = winner - } - } - - // Write merged state - if err := writeMergedStateToJSONL(jsonlPath, mergeResult.Merged); err != nil { - return fmt.Errorf("writing merged state: %w", err) - } - - // Import to database - if err := importFromJSONLInline(ctx, jsonlPath, false, false, false); err != nil { - return fmt.Errorf("importing merged state: %w", err) - } - - // Export to ensure consistency - if err := exportToJSONL(ctx, jsonlPath); err != nil { - return fmt.Errorf("exporting: %w", err) - } - - // Update base state - finalIssues, err := loadIssuesFromJSONL(jsonlPath) - if err != nil { - return fmt.Errorf("reloading final state: %w", err) - } - if err := saveBaseState(beadsDir, finalIssues); err != nil { - return fmt.Errorf("saving base state: %w", err) - } - - fmt.Printf("✓ Merge complete (%d conflicts resolved)\n", resolved) - - return nil -} - -// resolveSyncConflictsManually handles manual conflict resolution with interactive prompts. -func resolveSyncConflictsManually(ctx context.Context, jsonlPath, beadsDir string, conflictState *SyncConflictState, - baseMap, localMap, remoteMap map[string]*beads.Issue) error { - - // Build interactive conflicts list - var interactiveConflicts []InteractiveConflict - for _, c := range conflictState.Conflicts { - interactiveConflicts = append(interactiveConflicts, InteractiveConflict{ - IssueID: c.IssueID, - Local: localMap[c.IssueID], - Remote: remoteMap[c.IssueID], - Base: baseMap[c.IssueID], - }) - } - - // Run interactive resolution - resolvedIssues, skipped, err := resolveConflictsInteractively(interactiveConflicts) - if err != nil { - return fmt.Errorf("interactive resolution: %w", err) - } - - if skipped > 0 { - fmt.Printf("\n⚠ %d conflict(s) skipped - will remain unresolved\n", skipped) - } - - if len(resolvedIssues) == 0 && skipped == len(conflictState.Conflicts) { - fmt.Println("No conflicts were resolved") - return nil - } - - // Build the merged issue list: - // 1. Start with issues that weren't in conflict - // 2. Add the resolved issues - conflictIDSet := make(map[string]bool) - for _, c := range conflictState.Conflicts { - conflictIDSet[c.IssueID] = true - } - - // Build resolved issue map for quick lookup - resolvedMap := make(map[string]*beads.Issue) - for _, issue := range resolvedIssues { - if issue != nil { - resolvedMap[issue.ID] = issue - } - } - - // Collect all unique IDs from base, local, remote - allIDSet := make(map[string]bool) - for id := range baseMap { - allIDSet[id] = true - } - for id := range localMap { - allIDSet[id] = true - } - for id := range remoteMap { - allIDSet[id] = true - } - - // Build final merged list - var mergedIssues []*beads.Issue - for id := range allIDSet { - if conflictIDSet[id] { - // This was a conflict - if resolved, ok := resolvedMap[id]; ok { - // User resolved this conflict - use their choice - mergedIssues = append(mergedIssues, resolved) - } else { - // Skipped - keep local version in output, conflict remains for later - if local := localMap[id]; local != nil { - mergedIssues = append(mergedIssues, local) - } - } - } else { - // Not a conflict - use standard 3-way merge logic - local := localMap[id] - remote := remoteMap[id] - base := baseMap[id] - merged, _, _ := MergeIssue(base, local, remote) - if merged != nil { - mergedIssues = append(mergedIssues, merged) - } - } - } - - // Clear resolved conflicts (keep skipped ones) - if skipped == 0 { - if err := ClearSyncConflictState(beadsDir); err != nil { - return fmt.Errorf("clearing conflict state: %w", err) - } - } else { - // Update conflict state to only keep skipped conflicts - var remaining []SyncConflictRecord - for _, c := range conflictState.Conflicts { - if _, resolved := resolvedMap[c.IssueID]; !resolved { - remaining = append(remaining, c) - } - } - conflictState.Conflicts = remaining - if err := SaveSyncConflictState(beadsDir, conflictState); err != nil { - return fmt.Errorf("saving updated conflict state: %w", err) - } - } - - // Write merged state - if err := writeMergedStateToJSONL(jsonlPath, mergedIssues); err != nil { - return fmt.Errorf("writing merged state: %w", err) - } - - // Import to database - if err := importFromJSONLInline(ctx, jsonlPath, false, false, false); err != nil { - return fmt.Errorf("importing merged state: %w", err) - } - - // Export to ensure consistency - if err := exportToJSONL(ctx, jsonlPath); err != nil { - return fmt.Errorf("exporting: %w", err) - } - - // Update base state - finalIssues, err := loadIssuesFromJSONL(jsonlPath) - if err != nil { - return fmt.Errorf("reloading final state: %w", err) - } - if err := saveBaseState(beadsDir, finalIssues); err != nil { - return fmt.Errorf("saving base state: %w", err) - } - - resolvedCount := len(resolvedIssues) - fmt.Printf("\n✓ Manual resolution complete (%d resolved, %d skipped)\n", resolvedCount, skipped) - - return nil -} diff --git a/cmd/bd/sync_cwd_test.go b/cmd/bd/sync_cwd_test.go deleted file mode 100644 index 063ff9d79..000000000 --- a/cmd/bd/sync_cwd_test.go +++ /dev/null @@ -1,680 +0,0 @@ -//go:build cgo - -package main - -import ( - "context" - "os" - "os/exec" - "path/filepath" - "testing" - - "github.com/steveyegge/beads/internal/config" - "github.com/steveyegge/beads/internal/git" - "github.com/steveyegge/beads/internal/storage/dolt" - "github.com/steveyegge/beads/internal/types" -) - -// TestMultiRepoPathResolutionCWDInvariant verifies that path resolution for -// repos.additional produces the same absolute paths regardless of CWD. -// -// The bug (oss-lbp): Running from .beads/ caused paths like "oss/" to become -// ".beads/oss/" instead of "{repo}/oss/". This test ensures the fix works -// by verifying resolution from multiple CWDs produces identical results. -// -// Covers: T040-T042 -func TestMultiRepoPathResolutionCWDInvariant(t *testing.T) { - ctx := context.Background() - - // Store original working directory - originalWd, err := os.Getwd() - if err != nil { - t.Fatalf("failed to get original working directory: %v", err) - } - defer func() { _ = os.Chdir(originalWd) }() - - // Create temp repo structure - // Resolve symlinks to avoid macOS /var -> /private/var issues - tmpDir, err := filepath.EvalSymlinks(t.TempDir()) - if err != nil { - t.Fatalf("eval symlinks failed: %v", err) - } - - // Setup git repo - if err := setupGitRepoInDir(t, tmpDir); err != nil { - t.Fatalf("failed to setup git repo: %v", err) - } - - // Create .beads directory structure - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("failed to create .beads dir: %v", err) - } - - // Create subdirectory for testing CWD from subdir - subDir := filepath.Join(tmpDir, "src", "pkg") - if err := os.MkdirAll(subDir, 0755); err != nil { - t.Fatalf("failed to create subdir: %v", err) - } - - // Create oss/ directory (the multi-repo target) - ossDir := filepath.Join(tmpDir, "oss") - ossBeadsDir := filepath.Join(ossDir, ".beads") - if err := os.MkdirAll(ossBeadsDir, 0755); err != nil { - t.Fatalf("failed to create oss/.beads dir: %v", err) - } - - // Create config.yaml with relative path - configContent := `repos: - primary: "." - additional: - - oss/ -` - configPath := filepath.Join(beadsDir, "config.yaml") - if err := os.WriteFile(configPath, []byte(configContent), 0600); err != nil { - t.Fatalf("failed to write config file: %v", err) - } - - // Create database - dbPath := filepath.Join(beadsDir, "beads.db") - store, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - defer store.Close() - - // Set issue prefix - if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil { - t.Fatalf("failed to set issue_prefix: %v", err) - } - - // Create a test issue - issue := &types.Issue{ - ID: "test-1", - Title: "Test Issue", - Status: types.StatusOpen, - IssueType: types.TypeTask, - Priority: 2, - } - if err := store.CreateIssue(ctx, issue, "test"); err != nil { - t.Fatalf("failed to create issue: %v", err) - } - store.Close() - - // T040: Test from repo root - t.Run("T040_from_repo_root", func(t *testing.T) { - if err := os.Chdir(tmpDir); err != nil { - t.Fatalf("chdir to repo root failed: %v", err) - } - git.ResetCaches() - - // Initialize config - initConfigForTest(t) - - multiRepo := config.GetMultiRepoConfig() - if multiRepo == nil { - t.Fatal("GetMultiRepoConfig() returned nil") - } - - // The key assertion: "oss/" should resolve to {repo}/oss/ - if len(multiRepo.Additional) != 1 { - t.Fatalf("expected 1 additional repo, got %d", len(multiRepo.Additional)) - } - - // Verify config file used is in the right place - configUsed := config.ConfigFileUsed() - expectedConfig := filepath.Join(beadsDir, "config.yaml") - if configUsed != expectedConfig { - t.Errorf("ConfigFileUsed() = %q, want %q", configUsed, expectedConfig) - } - - t.Logf("From repo root: additional[0] = %q", multiRepo.Additional[0]) - t.Logf("ConfigFileUsed() = %q", configUsed) - }) - - // T041: Test from .beads/ directory (the bug trigger location) - t.Run("T041_from_beads_directory", func(t *testing.T) { - if err := os.Chdir(beadsDir); err != nil { - t.Fatalf("chdir to .beads failed: %v", err) - } - git.ResetCaches() - - // Re-initialize config from new CWD - initConfigForTest(t) - - multiRepo := config.GetMultiRepoConfig() - if multiRepo == nil { - t.Fatal("GetMultiRepoConfig() returned nil") - } - - if len(multiRepo.Additional) != 1 { - t.Fatalf("expected 1 additional repo, got %d", len(multiRepo.Additional)) - } - - // Verify config is still found correctly - configUsed := config.ConfigFileUsed() - expectedConfig := filepath.Join(beadsDir, "config.yaml") - if configUsed != expectedConfig { - t.Errorf("ConfigFileUsed() = %q, want %q", configUsed, expectedConfig) - } - - t.Logf("From .beads/: additional[0] = %q", multiRepo.Additional[0]) - t.Logf("ConfigFileUsed() = %q", configUsed) - }) - - // T042: Test from subdirectory - t.Run("T042_from_subdirectory", func(t *testing.T) { - if err := os.Chdir(subDir); err != nil { - t.Fatalf("chdir to subdir failed: %v", err) - } - git.ResetCaches() - - // Re-initialize config from new CWD - initConfigForTest(t) - - multiRepo := config.GetMultiRepoConfig() - if multiRepo == nil { - t.Fatal("GetMultiRepoConfig() returned nil") - } - - if len(multiRepo.Additional) != 1 { - t.Fatalf("expected 1 additional repo, got %d", len(multiRepo.Additional)) - } - - // Verify config is still found correctly - configUsed := config.ConfigFileUsed() - expectedConfig := filepath.Join(beadsDir, "config.yaml") - if configUsed != expectedConfig { - t.Errorf("ConfigFileUsed() = %q, want %q", configUsed, expectedConfig) - } - - t.Logf("From subdir: additional[0] = %q", multiRepo.Additional[0]) - t.Logf("ConfigFileUsed() = %q", configUsed) - }) -} - -// TestExportToMultiRepoCWDInvariant tests that ExportToMultiRepo produces -// consistent export paths regardless of CWD. -// -// This is an integration test that exercises the actual export code path -// which was affected by the bug. -func TestExportToMultiRepoCWDInvariant(t *testing.T) { - ctx := context.Background() - - // Store original working directory - originalWd, err := os.Getwd() - if err != nil { - t.Fatalf("failed to get original working directory: %v", err) - } - defer func() { _ = os.Chdir(originalWd) }() - - // Create temp repo structure - tmpDir, err := filepath.EvalSymlinks(t.TempDir()) - if err != nil { - t.Fatalf("eval symlinks failed: %v", err) - } - - // Setup git repo - if err := setupGitRepoInDir(t, tmpDir); err != nil { - t.Fatalf("failed to setup git repo: %v", err) - } - - // Create .beads directory - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("failed to create .beads dir: %v", err) - } - - // Create oss/.beads directory - ossBeadsDir := filepath.Join(tmpDir, "oss", ".beads") - if err := os.MkdirAll(ossBeadsDir, 0755); err != nil { - t.Fatalf("failed to create oss/.beads dir: %v", err) - } - - // Create config.yaml with relative path - configContent := `repos: - primary: "." - additional: - - oss/ -` - configPath := filepath.Join(beadsDir, "config.yaml") - if err := os.WriteFile(configPath, []byte(configContent), 0600); err != nil { - t.Fatalf("failed to write config file: %v", err) - } - - // Create database and issue once before CWD tests - dbPath := filepath.Join(beadsDir, "beads.db") - store, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - - // Set issue prefix - if err := store.SetConfig(ctx, "issue_prefix", "oss"); err != nil { - store.Close() - t.Fatalf("failed to set issue_prefix: %v", err) - } - - // Create a test issue for oss/ repo - issue := &types.Issue{ - ID: "oss-1", - Title: "OSS Issue", - Status: types.StatusOpen, - IssueType: types.TypeTask, - Priority: 2, - SourceRepo: "oss/", // This routes to additional repo - } - if err := store.CreateIssue(ctx, issue, "oss"); err != nil { - store.Close() - t.Fatalf("failed to create issue: %v", err) - } - store.Close() - - // Helper function to run export and check results - runExportTest := func(t *testing.T, testCwd string) string { - t.Helper() - - // Change to test CWD - if err := os.Chdir(testCwd); err != nil { - t.Fatalf("chdir to %s failed: %v", testCwd, err) - } - git.ResetCaches() - - // Initialize config - initConfigForTest(t) - - // Open existing store - store, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to open store: %v", err) - } - defer store.Close() - - // Run multi-repo export - results, err := store.ExportToMultiRepo(ctx) - if err != nil { - t.Fatalf("ExportToMultiRepo failed: %v", err) - } - - // Check that oss/ was exported - if results == nil { - t.Skip("ExportToMultiRepo is a no-op on Dolt backend (JSONL multi-repo not supported)") - } - - // The export should create issues.jsonl in oss/.beads/ - expectedPath := filepath.Join(ossBeadsDir, "issues.jsonl") - if _, err := os.Stat(expectedPath); os.IsNotExist(err) { - t.Errorf("expected %s to exist after export from %s", expectedPath, testCwd) - } - - return expectedPath - } - - // Test from repo root - t.Run("export_from_repo_root", func(t *testing.T) { - path := runExportTest(t, tmpDir) - t.Logf("Export from repo root created: %s", path) - }) - - // Test from .beads/ directory - t.Run("export_from_beads_dir", func(t *testing.T) { - path := runExportTest(t, beadsDir) - t.Logf("Export from .beads/ created: %s", path) - - // Key assertion: should NOT create .beads/oss/.beads/issues.jsonl - badPath := filepath.Join(beadsDir, "oss", ".beads", "issues.jsonl") - if _, err := os.Stat(badPath); err == nil { - t.Errorf("BUG: export created %s (CWD-relative path)", badPath) - } - }) - - // Test from subdirectory - subDir := filepath.Join(tmpDir, "src") - if err := os.MkdirAll(subDir, 0755); err != nil { - t.Fatalf("failed to create subdir: %v", err) - } - - t.Run("export_from_subdirectory", func(t *testing.T) { - path := runExportTest(t, subDir) - t.Logf("Export from subdir created: %s", path) - }) -} - -// TestSyncModePathResolution tests path resolution across different sync modes. -// -// Covers: T050-T052 -func TestSyncModePathResolution(t *testing.T) { - ctx := context.Background() - - // Store original working directory - originalWd, err := os.Getwd() - if err != nil { - t.Fatalf("failed to get original working directory: %v", err) - } - defer func() { _ = os.Chdir(originalWd) }() - - // T050: Normal sync mode path resolution - t.Run("T050_normal_sync_mode", func(t *testing.T) { - // Restore CWD at end of subtest to prevent interference with subsequent tests. - // t.TempDir() cleanup happens after subtest returns, so CWD must be restored first. - subtestWd, err := os.Getwd() - if err != nil { - t.Fatalf("failed to get subtest working directory: %v", err) - } - defer func() { _ = os.Chdir(subtestWd) }() - - tmpDir, err := filepath.EvalSymlinks(t.TempDir()) - if err != nil { - t.Fatalf("eval symlinks failed: %v", err) - } - - // Setup git repo - if err := setupGitRepoInDir(t, tmpDir); err != nil { - t.Fatalf("failed to setup git repo: %v", err) - } - - // Create .beads directory - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("failed to create .beads dir: %v", err) - } - - // Create oss/.beads directory - ossBeadsDir := filepath.Join(tmpDir, "oss", ".beads") - if err := os.MkdirAll(ossBeadsDir, 0755); err != nil { - t.Fatalf("failed to create oss/.beads dir: %v", err) - } - - // Create config.yaml with relative path - configContent := `repos: - primary: "." - additional: - - oss/ -` - configPath := filepath.Join(beadsDir, "config.yaml") - if err := os.WriteFile(configPath, []byte(configContent), 0600); err != nil { - t.Fatalf("failed to write config file: %v", err) - } - - // Create database - dbPath := filepath.Join(beadsDir, "beads.db") - store, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - - // Set issue prefix - if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil { - store.Close() - t.Fatalf("failed to set issue_prefix: %v", err) - } - - // Create issue for oss/ - issue := &types.Issue{ - ID: "test-100", - Title: "Normal mode issue", - Status: types.StatusOpen, - IssueType: types.TypeTask, - Priority: 2, - SourceRepo: "oss/", - } - if err := store.CreateIssue(ctx, issue, "test"); err != nil { - store.Close() - t.Fatalf("failed to create issue: %v", err) - } - - // Change to repo root and initialize config - if err := os.Chdir(tmpDir); err != nil { - store.Close() - t.Fatalf("chdir failed: %v", err) - } - git.ResetCaches() - - initConfigForTest(t) - - // Export - results, err := store.ExportToMultiRepo(ctx) - store.Close() - if err != nil { - t.Fatalf("ExportToMultiRepo failed: %v", err) - } - - if results == nil || len(results) == 0 { - t.Skip("ExportToMultiRepo is a no-op on Dolt backend (JSONL multi-repo not supported)") - } - - // Verify export created file in correct location - expectedPath := filepath.Join(ossBeadsDir, "issues.jsonl") - if _, err := os.Stat(expectedPath); os.IsNotExist(err) { - t.Errorf("expected %s to exist", expectedPath) - } - - t.Logf("Normal sync mode export results: %v", results) - }) - - // T051: Sync-branch mode with daemon context - t.Run("T051_sync_branch_mode", func(t *testing.T) { - // Restore CWD at end of subtest to prevent interference with subsequent tests. - subtestWd, err := os.Getwd() - if err != nil { - t.Fatalf("failed to get subtest working directory: %v", err) - } - defer func() { _ = os.Chdir(subtestWd) }() - - tmpDir, err := filepath.EvalSymlinks(t.TempDir()) - if err != nil { - t.Fatalf("eval symlinks failed: %v", err) - } - - // Setup git repo - if err := setupGitRepoInDir(t, tmpDir); err != nil { - t.Fatalf("failed to setup git repo: %v", err) - } - - // Create .beads directory - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("failed to create .beads dir: %v", err) - } - - // Create oss/.beads directory - ossBeadsDir := filepath.Join(tmpDir, "oss", ".beads") - if err := os.MkdirAll(ossBeadsDir, 0755); err != nil { - t.Fatalf("failed to create oss/.beads dir: %v", err) - } - - // Create config.yaml with sync-branch AND multi-repo - configContent := `sync: - branch: beads-sync -repos: - primary: "." - additional: - - oss/ -` - configPath := filepath.Join(beadsDir, "config.yaml") - if err := os.WriteFile(configPath, []byte(configContent), 0600); err != nil { - t.Fatalf("failed to write config file: %v", err) - } - - // Create the sync branch - if err := exec.Command("git", "-C", tmpDir, "branch", "beads-sync").Run(); err != nil { - t.Fatalf("failed to create sync branch: %v", err) - } - - // Create database - dbPath := filepath.Join(beadsDir, "beads.db") - store, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - - // Set issue prefix - if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil { - store.Close() - t.Fatalf("failed to set issue_prefix: %v", err) - } - - // Create issue for oss/ - issue := &types.Issue{ - ID: "test-200", - Title: "Sync-branch mode issue", - Status: types.StatusOpen, - IssueType: types.TypeTask, - Priority: 2, - SourceRepo: "oss/", - } - if err := store.CreateIssue(ctx, issue, "test"); err != nil { - store.Close() - t.Fatalf("failed to create issue: %v", err) - } - - // Simulate daemon context: CWD is .beads/ - if err := os.Chdir(beadsDir); err != nil { - store.Close() - t.Fatalf("chdir to .beads/ failed: %v", err) - } - git.ResetCaches() - - initConfigForTest(t) - - // Export from daemon-like context - results, err := store.ExportToMultiRepo(ctx) - store.Close() - if err != nil { - t.Fatalf("ExportToMultiRepo failed: %v", err) - } - - if results == nil || len(results) == 0 { - t.Skip("ExportToMultiRepo is a no-op on Dolt backend (JSONL multi-repo not supported)") - } - - // Key assertion: should still export to correct location - expectedPath := filepath.Join(ossBeadsDir, "issues.jsonl") - if _, err := os.Stat(expectedPath); os.IsNotExist(err) { - t.Errorf("expected %s to exist (sync-branch mode from .beads/)", expectedPath) - } - - // Verify no spurious directory created - badPath := filepath.Join(beadsDir, "oss", ".beads", "issues.jsonl") - if _, err := os.Stat(badPath); err == nil { - t.Errorf("BUG: created %s (CWD-relative in sync-branch mode)", badPath) - } - - t.Logf("Sync-branch mode export results: %v", results) - }) - - // T052: External BEADS_DIR mode - t.Run("T052_external_beads_dir_mode", func(t *testing.T) { - // Restore CWD at end of subtest to prevent interference with subsequent tests. - subtestWd, err := os.Getwd() - if err != nil { - t.Fatalf("failed to get subtest working directory: %v", err) - } - defer func() { _ = os.Chdir(subtestWd) }() - - // Create main project repo - projectDir, err := filepath.EvalSymlinks(t.TempDir()) - if err != nil { - t.Fatalf("eval symlinks failed: %v", err) - } - if err := setupGitRepoInDir(t, projectDir); err != nil { - t.Fatalf("failed to setup project repo: %v", err) - } - - // Create external beads repo - externalDir, err := filepath.EvalSymlinks(t.TempDir()) - if err != nil { - t.Fatalf("eval symlinks failed: %v", err) - } - if err := setupGitRepoInDir(t, externalDir); err != nil { - t.Fatalf("failed to setup external repo: %v", err) - } - - // Create .beads in external repo - externalBeadsDir := filepath.Join(externalDir, ".beads") - if err := os.MkdirAll(externalBeadsDir, 0755); err != nil { - t.Fatalf("failed to create external .beads: %v", err) - } - - // Create oss/.beads in external repo (sibling to external .beads) - ossBeadsDir := filepath.Join(externalDir, "oss", ".beads") - if err := os.MkdirAll(ossBeadsDir, 0755); err != nil { - t.Fatalf("failed to create oss/.beads: %v", err) - } - - // Create config.yaml in external repo with relative path - configContent := `repos: - primary: "." - additional: - - oss/ -` - configPath := filepath.Join(externalBeadsDir, "config.yaml") - if err := os.WriteFile(configPath, []byte(configContent), 0600); err != nil { - t.Fatalf("failed to write config file: %v", err) - } - - // Create database in external repo - dbPath := filepath.Join(externalBeadsDir, "beads.db") - store, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - - // Set issue prefix - if err := store.SetConfig(ctx, "issue_prefix", "ext"); err != nil { - store.Close() - t.Fatalf("failed to set issue_prefix: %v", err) - } - - // Create issue for oss/ (ext prefix matches issue ID) - issue := &types.Issue{ - ID: "ext-300", - Title: "External mode issue", - Status: types.StatusOpen, - IssueType: types.TypeTask, - Priority: 2, - SourceRepo: "oss/", - } - if err := store.CreateIssue(ctx, issue, "ext"); err != nil { - store.Close() - t.Fatalf("failed to create issue: %v", err) - } - - // Simulate external mode: CWD is project repo, BEADS_DIR points elsewhere - if err := os.Chdir(projectDir); err != nil { - store.Close() - t.Fatalf("chdir to project failed: %v", err) - } - git.ResetCaches() - - // Initialize config from external location - // In external mode, config is loaded from BEADS_DIR, not CWD - // We simulate this by changing to external dir for config init - if err := os.Chdir(externalDir); err != nil { - store.Close() - t.Fatalf("chdir to external failed: %v", err) - } - git.ResetCaches() - - initConfigForTest(t) - - // Export - results, err := store.ExportToMultiRepo(ctx) - store.Close() - if err != nil { - t.Fatalf("ExportToMultiRepo failed: %v", err) - } - - if results == nil || len(results) == 0 { - t.Skip("ExportToMultiRepo is a no-op on Dolt backend (JSONL multi-repo not supported)") - } - - // Verify export in correct location - expectedPath := filepath.Join(ossBeadsDir, "issues.jsonl") - if _, err := os.Stat(expectedPath); os.IsNotExist(err) { - t.Errorf("expected %s to exist (external mode)", expectedPath) - } - - t.Logf("External BEADS_DIR mode export results: %v", results) - }) -} diff --git a/cmd/bd/sync_export_incremental_test.go b/cmd/bd/sync_export_incremental_test.go deleted file mode 100644 index d9d963b35..000000000 --- a/cmd/bd/sync_export_incremental_test.go +++ /dev/null @@ -1,95 +0,0 @@ -package main - -import ( - "encoding/json" - "os" - "path/filepath" - "testing" - - "github.com/steveyegge/beads/internal/types" -) - -func TestReadJSONLToMap(t *testing.T) { - tmpDir := t.TempDir() - jsonlPath := filepath.Join(tmpDir, "test.jsonl") - - // Create test JSONL with 3 issues - issues := []types.Issue{ - {ID: "test-001", Title: "First", Status: types.StatusOpen}, - {ID: "test-002", Title: "Second", Status: types.StatusInProgress}, - {ID: "test-003", Title: "Third", Status: types.StatusClosed}, - } - - var content string - for _, issue := range issues { - data, _ := json.Marshal(issue) - content += string(data) + "\n" - } - - if err := os.WriteFile(jsonlPath, []byte(content), 0644); err != nil { - t.Fatalf("failed to write test file: %v", err) - } - - // Test readJSONLToMap - issueMap, ids, err := readJSONLToMap(jsonlPath) - if err != nil { - t.Fatalf("readJSONLToMap failed: %v", err) - } - - // Verify count - if len(issueMap) != 3 { - t.Errorf("expected 3 issues in map, got %d", len(issueMap)) - } - if len(ids) != 3 { - t.Errorf("expected 3 IDs, got %d", len(ids)) - } - - // Verify order preserved - expectedOrder := []string{"test-001", "test-002", "test-003"} - for i, id := range ids { - if id != expectedOrder[i] { - t.Errorf("ID order mismatch at %d: expected %s, got %s", i, expectedOrder[i], id) - } - } - - // Verify content can be unmarshaled - for id, rawJSON := range issueMap { - var issue types.Issue - if err := json.Unmarshal(rawJSON, &issue); err != nil { - t.Errorf("failed to unmarshal issue %s: %v", id, err) - } - if issue.ID != id { - t.Errorf("ID mismatch: expected %s, got %s", id, issue.ID) - } - } -} - -func TestReadJSONLToMapWithMalformedLines(t *testing.T) { - tmpDir := t.TempDir() - jsonlPath := filepath.Join(tmpDir, "test.jsonl") - - content := `{"id": "test-001", "title": "Good"} -{invalid json} -{"id": "test-002", "title": "Also Good"} - -{"id": "", "title": "No ID"} -{"id": "test-003", "title": "Third Good"} -` - - if err := os.WriteFile(jsonlPath, []byte(content), 0644); err != nil { - t.Fatalf("failed to write test file: %v", err) - } - - issueMap, ids, err := readJSONLToMap(jsonlPath) - if err != nil { - t.Fatalf("readJSONLToMap failed: %v", err) - } - - // Should have 3 valid issues (skipped invalid JSON, empty line, and empty ID) - if len(issueMap) != 3 { - t.Errorf("expected 3 issues, got %d", len(issueMap)) - } - if len(ids) != 3 { - t.Errorf("expected 3 IDs, got %d", len(ids)) - } -} diff --git a/cmd/bd/sync_external_test.go b/cmd/bd/sync_external_test.go deleted file mode 100644 index 2279f499c..000000000 --- a/cmd/bd/sync_external_test.go +++ /dev/null @@ -1,365 +0,0 @@ -package main - -import ( - "context" - "os" - "os/exec" - "path/filepath" - "strings" - "testing" - - "github.com/steveyegge/beads/internal/git" -) - -// TestExternalBeadsDirE2E tests the full external BEADS_DIR flow. -// This is an end-to-end regression test for PR#918. -// -// When BEADS_DIR points to a separate git repository (external mode), -// sync operations should work correctly: -// 1. Changes are committed to the external beads repo (not the project repo) -// 2. Pulls from the external repo bring in remote changes -// 3. The merge algorithm works correctly across repo boundaries -func TestExternalBeadsDirE2E(t *testing.T) { - ctx := context.Background() - - // Store original working directory - originalWd, err := os.Getwd() - if err != nil { - t.Fatalf("failed to get original working directory: %v", err) - } - - // Setup: Create the main project repo - projectDir := t.TempDir() - if err := setupGitRepoInDir(t, projectDir); err != nil { - t.Fatalf("failed to setup project repo: %v", err) - } - - // Setup: Create a separate external beads repo - // Resolve symlinks to avoid macOS /var -> /private/var issues - externalDir, err := filepath.EvalSymlinks(t.TempDir()) - if err != nil { - t.Fatalf("eval symlinks failed: %v", err) - } - if err := setupGitRepoInDir(t, externalDir); err != nil { - t.Fatalf("failed to setup external repo: %v", err) - } - - // Create .beads directory in external repo - externalBeadsDir := filepath.Join(externalDir, ".beads") - if err := os.MkdirAll(externalBeadsDir, 0755); err != nil { - t.Fatalf("failed to create external .beads dir: %v", err) - } - - // Create issues.jsonl in external beads repo with initial issue - jsonlPath := filepath.Join(externalBeadsDir, "issues.jsonl") - issue1 := `{"id":"ext-1","title":"External Issue 1","status":"open","issue_type":"task","priority":2,"created_at":"2025-01-01T00:00:00Z","updated_at":"2025-01-01T00:00:00Z"}` - if err := os.WriteFile(jsonlPath, []byte(issue1+"\n"), 0644); err != nil { - t.Fatalf("write external JSONL failed: %v", err) - } - - // Commit initial beads files in external repo - runGitInDir(t, externalDir, "add", ".beads") - runGitInDir(t, externalDir, "commit", "-m", "initial beads setup") - t.Log("✓ External beads repo initialized with issue ext-1") - - // Change to project directory (simulating user's project) - if err := os.Chdir(projectDir); err != nil { - t.Fatalf("chdir to project failed: %v", err) - } - defer func() { _ = os.Chdir(originalWd) }() - - // Reset git caches after directory change - git.ResetCaches() - - // Test 1: isExternalBeadsDir should detect external repo - if !isExternalBeadsDir(ctx, externalBeadsDir) { - t.Error("isExternalBeadsDir should return true for external beads dir") - } - t.Log("✓ External beads dir correctly detected") - - // Test 2: getRepoRootFromPath should correctly identify external repo root - repoRoot, err := getRepoRootFromPath(ctx, externalBeadsDir) - if err != nil { - t.Fatalf("getRepoRootFromPath failed: %v", err) - } - // Normalize paths for comparison - resolvedExternal, _ := filepath.EvalSymlinks(externalDir) - if repoRoot != resolvedExternal { - t.Errorf("getRepoRootFromPath = %q, want %q", repoRoot, resolvedExternal) - } - t.Logf("✓ getRepoRootFromPath correctly identifies external repo: %s", repoRoot) - - // Test 3: pullFromExternalBeadsRepo should handle no-remote gracefully - err = pullFromExternalBeadsRepo(ctx, externalBeadsDir) - if err != nil { - t.Errorf("pullFromExternalBeadsRepo should handle no-remote: %v", err) - } - t.Log("✓ Pull from external beads repo handled no-remote correctly") - - // Test 4: Create new issue and commit to external repo - issue2 := `{"id":"ext-2","title":"External Issue 2","status":"open","issue_type":"task","priority":2,"created_at":"2025-01-02T00:00:00Z","updated_at":"2025-01-02T00:00:00Z"}` - combinedContent := issue1 + "\n" + issue2 + "\n" - if err := os.WriteFile(jsonlPath, []byte(combinedContent), 0644); err != nil { - t.Fatalf("write updated JSONL failed: %v", err) - } - - // Use commitToExternalBeadsRepo (don't push since no real remote) - committed, err := commitToExternalBeadsRepo(ctx, externalBeadsDir, "add ext-2", false) - if err != nil { - t.Fatalf("commitToExternalBeadsRepo failed: %v", err) - } - if !committed { - t.Error("expected commit to succeed for new issue") - } - t.Log("✓ Successfully committed issue ext-2 to external beads repo") - - // Test 5: Verify commit was made in external repo (not project repo) - // Check external repo has the commit - logOutput := getGitOutputInDir(t, externalDir, "log", "--oneline", "-1") - if !strings.Contains(logOutput, "add ext-2") { - t.Errorf("external repo should have commit, got: %s", logOutput) - } - t.Log("✓ Commit correctly made in external repo") - - // Test 6: Verify project repo is unchanged - projectLogOutput := getGitOutputInDir(t, projectDir, "log", "--oneline", "-1") - if strings.Contains(projectLogOutput, "add ext-2") { - t.Error("project repo should not have beads commit") - } - t.Log("✓ Project repo correctly unchanged") - - // Test 7: Verify JSONL content is correct - content, err := os.ReadFile(jsonlPath) - if err != nil { - t.Fatalf("failed to read JSONL: %v", err) - } - contentStr := string(content) - if !strings.Contains(contentStr, "ext-1") || !strings.Contains(contentStr, "ext-2") { - t.Errorf("JSONL should contain both issues, got: %s", contentStr) - } - t.Log("✓ JSONL contains both issues") - - t.Log("✓ External BEADS_DIR E2E test completed") -} - -// TestExternalBeadsDirDetection tests various edge cases for external beads dir detection. -func TestExternalBeadsDirDetection(t *testing.T) { - ctx := context.Background() - - // Store original working directory - originalWd, err := os.Getwd() - if err != nil { - t.Fatalf("failed to get original working directory: %v", err) - } - - t.Run("same repo returns false", func(t *testing.T) { - // Setup a single repo - repoDir := t.TempDir() - if err := setupGitRepoInDir(t, repoDir); err != nil { - t.Fatalf("setup failed: %v", err) - } - - beadsDir := filepath.Join(repoDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - // Change to repo dir - if err := os.Chdir(repoDir); err != nil { - t.Fatalf("chdir failed: %v", err) - } - defer func() { _ = os.Chdir(originalWd) }() - git.ResetCaches() - - // Same repo should return false - if isExternalBeadsDir(ctx, beadsDir) { - t.Error("isExternalBeadsDir should return false for same repo") - } - }) - - t.Run("different repo returns true", func(t *testing.T) { - // Setup two separate repos - projectDir := t.TempDir() - if err := setupGitRepoInDir(t, projectDir); err != nil { - t.Fatalf("setup project failed: %v", err) - } - - externalDir, err := filepath.EvalSymlinks(t.TempDir()) - if err != nil { - t.Fatalf("eval symlinks failed: %v", err) - } - if err := setupGitRepoInDir(t, externalDir); err != nil { - t.Fatalf("setup external failed: %v", err) - } - - beadsDir := filepath.Join(externalDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - // Change to project dir - if err := os.Chdir(projectDir); err != nil { - t.Fatalf("chdir failed: %v", err) - } - defer func() { _ = os.Chdir(originalWd) }() - git.ResetCaches() - - // Different repo should return true - if !isExternalBeadsDir(ctx, beadsDir) { - t.Error("isExternalBeadsDir should return true for different repo") - } - }) - - t.Run("non-git directory returns false", func(t *testing.T) { - // Setup a repo for cwd - repoDir := t.TempDir() - if err := setupGitRepoInDir(t, repoDir); err != nil { - t.Fatalf("setup failed: %v", err) - } - - // Non-git beads dir - nonGitDir := t.TempDir() - beadsDir := filepath.Join(nonGitDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - // Change to repo dir - if err := os.Chdir(repoDir); err != nil { - t.Fatalf("chdir failed: %v", err) - } - defer func() { _ = os.Chdir(originalWd) }() - git.ResetCaches() - - // Non-git dir should return false (can't determine, assume local) - if isExternalBeadsDir(ctx, beadsDir) { - t.Error("isExternalBeadsDir should return false for non-git directory") - } - }) -} - -// TestCommitToExternalBeadsRepo tests the external repo commit function. -func TestCommitToExternalBeadsRepo(t *testing.T) { - ctx := context.Background() - - t.Run("commits changes to external repo", func(t *testing.T) { - // Setup external repo - externalDir, err := filepath.EvalSymlinks(t.TempDir()) - if err != nil { - t.Fatalf("eval symlinks failed: %v", err) - } - if err := setupGitRepoInDir(t, externalDir); err != nil { - t.Fatalf("setup failed: %v", err) - } - - beadsDir := filepath.Join(externalDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - // Write initial JSONL - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - if err := os.WriteFile(jsonlPath, []byte(`{"id":"test-1"}`+"\n"), 0644); err != nil { - t.Fatalf("write failed: %v", err) - } - - // Commit - committed, err := commitToExternalBeadsRepo(ctx, beadsDir, "test commit", false) - if err != nil { - t.Fatalf("commit failed: %v", err) - } - if !committed { - t.Error("expected commit to succeed") - } - - // Verify commit exists - logOutput := getGitOutputInDir(t, externalDir, "log", "--oneline", "-1") - if !strings.Contains(logOutput, "test commit") { - t.Errorf("commit not found in log: %s", logOutput) - } - }) - - t.Run("returns false when no changes", func(t *testing.T) { - // Setup external repo - externalDir, err := filepath.EvalSymlinks(t.TempDir()) - if err != nil { - t.Fatalf("eval symlinks failed: %v", err) - } - if err := setupGitRepoInDir(t, externalDir); err != nil { - t.Fatalf("setup failed: %v", err) - } - - beadsDir := filepath.Join(externalDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - // Write and commit JSONL - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - if err := os.WriteFile(jsonlPath, []byte(`{"id":"test-1"}`+"\n"), 0644); err != nil { - t.Fatalf("write failed: %v", err) - } - runGitInDir(t, externalDir, "add", ".beads") - runGitInDir(t, externalDir, "commit", "-m", "initial") - - // Try to commit again with no changes - committed, err := commitToExternalBeadsRepo(ctx, beadsDir, "no changes", false) - if err != nil { - t.Fatalf("commit failed: %v", err) - } - if committed { - t.Error("expected no commit when no changes") - } - }) -} - -// Helper: Setup git repo in a specific directory (doesn't change cwd) -func setupGitRepoInDir(t *testing.T, dir string) error { - t.Helper() - - // Initialize git repo - if err := exec.Command("git", "-C", dir, "init", "--initial-branch=main").Run(); err != nil { - return err - } - - // Configure git - _ = exec.Command("git", "-C", dir, "config", "user.email", "test@test.com").Run() - _ = exec.Command("git", "-C", dir, "config", "user.name", "Test User").Run() - - // Create initial commit - readmePath := filepath.Join(dir, "README.md") - if err := os.WriteFile(readmePath, []byte("# Test Repo\n"), 0644); err != nil { - return err - } - if err := exec.Command("git", "-C", dir, "add", ".").Run(); err != nil { - return err - } - if err := exec.Command("git", "-C", dir, "commit", "-m", "initial commit").Run(); err != nil { - return err - } - - return nil -} - -// Helper: Run git command in a specific directory -func runGitInDir(t *testing.T, dir string, args ...string) { - t.Helper() - cmdArgs := append([]string{"-C", dir}, args...) - cmd := exec.Command("git", cmdArgs...) - output, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("git %v failed: %v\n%s", args, err, output) - } -} - -// Helper: Get git output from a specific directory -func getGitOutputInDir(t *testing.T, dir string, args ...string) string { - t.Helper() - cmdArgs := append([]string{"-C", dir}, args...) - cmd := exec.Command("git", cmdArgs...) - output, err := cmd.Output() - if err != nil { - t.Fatalf("git %v failed: %v", args, err) - } - return string(output) -} diff --git a/cmd/bd/sync_git_permission_test.go b/cmd/bd/sync_git_permission_test.go deleted file mode 100644 index 224707271..000000000 --- a/cmd/bd/sync_git_permission_test.go +++ /dev/null @@ -1,157 +0,0 @@ -package main - -import ( - "testing" -) - -// TestIsPushPermissionDenied tests the isPushPermissionDenied function -// with various error messages from different Git hosting providers. -func TestIsPushPermissionDenied(t *testing.T) { - tests := map[string]struct { - output string - expected bool - }{ - // GitHub errors - "github_403": { - output: "remote: Permission to owner/repo.git denied to user.\nfatal: unable to access 'https://github.com/owner/repo.git/': The requested URL returned error: 403", - expected: true, - }, - "github_permission_denied": { - output: "ERROR: Permission to owner/repo.git denied to user.", - expected: true, - }, - "github_ssh_permission": { - output: "Permission denied (publickey).\nfatal: Could not read from remote repository.", - expected: true, - }, - - // GitLab errors - "gitlab_not_allowed": { - output: "remote: GitLab: You are not allowed to push code to this project.\nTo gitlab.com:owner/repo.git\n! [remote rejected] main -> main (pre-receive hook declined)", - expected: true, - }, - "gitlab_permission": { - output: "remote: You are not allowed to push code to protected branches on this project.", - expected: true, - }, - - // Bitbucket errors - "bitbucket_403": { - output: "remote: HTTP Basic: Access denied\nfatal: Authentication failed for 'https://bitbucket.org/owner/repo.git/'", - expected: true, - }, - - // Generic permission errors - "generic_permission_denied": { - output: "fatal: remote error: permission denied", - expected: true, - }, - "generic_could_not_read": { - output: "fatal: Could not read from remote repository.\n\nPlease make sure you have the correct access rights\nand the repository exists.", - expected: true, - }, - "generic_authentication_failed": { - output: "fatal: Authentication failed for 'https://example.com/repo.git/'", - expected: true, - }, - "generic_unable_to_access": { - output: "fatal: unable to access 'https://example.com/repo.git/': URL using bad/illegal format or missing URL", - expected: true, - }, - - // Non-permission errors (should NOT trigger) - "fetch_first": { - output: "To github.com:owner/repo.git\n! [rejected] main -> main (fetch first)\nerror: failed to push some refs", - expected: false, - }, - "non_fast_forward": { - output: "To github.com:owner/repo.git\n! [rejected] main -> main (non-fast-forward)\nerror: failed to push some refs", - expected: false, - }, - "network_error": { - output: "fatal: unable to connect to github.com:\nCould not connect to server", - expected: false, - }, - "no_upstream": { - output: "fatal: The current branch main has no upstream branch.\nTo push the current branch and set the remote as upstream, use\n\n git push --set-upstream origin main", - expected: false, - }, - "branch_protected": { - output: "remote: error: GH006: Protected branch update failed for refs/heads/main.", - expected: false, - }, - "empty_output": { - output: "", - expected: false, - }, - "success_output": { - output: "To github.com:owner/repo.git\n abc123..def456 main -> main", - expected: false, - }, - - // Edge cases - "case_insensitive_403": { - output: "The Requested URL Returned Error: 403", - expected: true, - }, - "case_insensitive_permission": { - output: "PERMISSION DENIED", - expected: true, - }, - "partial_match_403_in_sha": { - // This is a tricky case - "403" in the middle of a hash - // We accept this false positive since it's rare and better to over-detect - output: "commit 403abc123 pushed successfully", - expected: true, - }, - } - - for name, tt := range tests { - t.Run(name, func(t *testing.T) { - got := isPushPermissionDenied(tt.output) - if got != tt.expected { - t.Errorf("isPushPermissionDenied(%q) = %v, want %v", tt.output, got, tt.expected) - } - }) - } -} - -// TestIsPushPermissionDenied_ProviderSpecific tests specific provider error formats -// to ensure we handle the most common cases from major Git hosting platforms. -func TestIsPushPermissionDenied_ProviderSpecific(t *testing.T) { - // These are real error messages captured from various providers - providerErrors := []struct { - name string - provider string - output string - }{ - { - name: "GitHub HTTPS with PAT denied", - provider: "GitHub", - output: "remote: Permission to steveyegge/beads.git denied to contributor.\nfatal: unable to access 'https://github.com/steveyegge/beads.git/': The requested URL returned error: 403", - }, - { - name: "GitHub SSH key not authorized", - provider: "GitHub", - output: "ERROR: Permission to owner/repo.git denied to user.\nfatal: Could not read from remote repository.\n\nPlease make sure you have the correct access rights\nand the repository exists.", - }, - { - name: "GitLab protected branch", - provider: "GitLab", - output: "remote: GitLab: You are not allowed to push code to this project.\nTo gitlab.com:owner/repo.git\n ! [remote rejected] main -> main (pre-receive hook declined)\nerror: failed to push some refs to 'gitlab.com:owner/repo.git'", - }, - { - name: "Bitbucket access denied", - provider: "Bitbucket", - output: "remote: You are not allowed to push to this repository.\nfatal: Could not read from remote repository.", - }, - } - - for _, tc := range providerErrors { - t.Run(tc.name, func(t *testing.T) { - if !isPushPermissionDenied(tc.output) { - t.Errorf("%s error not detected as permission denied:\n%s", tc.provider, tc.output) - } - }) - } -} diff --git a/cmd/bd/sync_git_remote_test.go b/cmd/bd/sync_git_remote_test.go deleted file mode 100644 index 8b1dbf739..000000000 --- a/cmd/bd/sync_git_remote_test.go +++ /dev/null @@ -1,88 +0,0 @@ -//go:build cgo - -package main - -import ( - "context" - "path/filepath" - "testing" - - "github.com/steveyegge/beads/internal/config" -) - -// resetConfigForRemoteTest clears viper config state without loading -// the real config.yaml. This prevents sync.mode from config.yaml -// (e.g., dolt-native in production workspace) from overriding test values. -func resetConfigForRemoteTest(t *testing.T) { - t.Helper() - config.ResetForTesting() - t.Cleanup(config.ResetForTesting) -} - -// NOTE: TestDoExportSync_*, TestDoPullFirstSync_*, and TestRemoteStorageInterfaceCheck -// were removed because they depended on the memory backend's mockRemoteStore pattern -// for Push/Pull error injection. With the dolt-native migration (Phase 7), the global -// store is *dolt.DoltStore which doesn't support mock injection. Sync mode functionality -// is tested through integration tests with real dolt remotes. - -// TestShouldUseDoltRemote_ModeSelection verifies the mode -> Dolt remote mapping -// using a real dolt store. -func TestShouldUseDoltRemote_ModeSelection(t *testing.T) { - ctx := context.Background() - resetConfigForRemoteTest(t) - - tests := []struct { - mode string - wantUse bool - }{ - {SyncModeGitPortable, false}, - {SyncModeRealtime, false}, - {SyncModeDoltNative, true}, - {SyncModeBeltAndSuspenders, true}, - } - - for _, tt := range tests { - t.Run(tt.mode, func(t *testing.T) { - testStore := newTestStoreWithPrefix(t, filepath.Join(t.TempDir(), "test.db"), "test") - if err := testStore.SetConfig(ctx, SyncModeConfigKey, tt.mode); err != nil { - t.Fatalf("set mode: %v", err) - } - - got := ShouldUseDoltRemote(ctx, testStore) - if got != tt.wantUse { - t.Errorf("ShouldUseDoltRemote() = %v, want %v", got, tt.wantUse) - } - }) - } -} - -// TestShouldExportJSONL_DoltNative_False verifies that JSONL export is disabled -// in dolt-native mode using a real dolt store. -func TestShouldExportJSONL_DoltNative_False(t *testing.T) { - ctx := context.Background() - resetConfigForRemoteTest(t) - - tests := []struct { - mode string - wantExport bool - }{ - {SyncModeGitPortable, true}, - {SyncModeRealtime, true}, - {SyncModeDoltNative, false}, - {SyncModeBeltAndSuspenders, true}, - } - - for _, tt := range tests { - t.Run(tt.mode, func(t *testing.T) { - testStore := newTestStoreWithPrefix(t, filepath.Join(t.TempDir(), "test.db"), "test") - if err := testStore.SetConfig(ctx, SyncModeConfigKey, tt.mode); err != nil { - t.Fatalf("set mode: %v", err) - } - - got := ShouldExportJSONL(ctx, testStore) - if got != tt.wantExport { - t.Errorf("ShouldExportJSONL() = %v, want %v", got, tt.wantExport) - } - }) - } -} diff --git a/cmd/bd/sync_git_test.go b/cmd/bd/sync_git_test.go deleted file mode 100644 index c37208e8c..000000000 --- a/cmd/bd/sync_git_test.go +++ /dev/null @@ -1,750 +0,0 @@ -package main - -import ( - "context" - "os" - "os/exec" - "path/filepath" - "runtime" - "strings" - "testing" - - "github.com/steveyegge/beads/internal/beads" - "github.com/steveyegge/beads/internal/git" -) - -// setupGitRepoWithBeads creates a temporary git repository with a .beads directory. -// Returns the repo path and cleanup function. -func setupGitRepoWithBeads(t *testing.T) (repoPath string, cleanup func()) { - t.Helper() - - tmpDir := newGitRepo(t) - originalWd, err := os.Getwd() - if err != nil { - t.Fatalf("failed to get working directory: %v", err) - } - - if err := os.Chdir(tmpDir); err != nil { - t.Fatalf("failed to change to temp directory: %v", err) - } - - git.ResetCaches() - beads.ResetCaches() - - // Create .beads directory with issues.jsonl - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - _ = os.Chdir(originalWd) - t.Fatalf("failed to create .beads directory: %v", err) - } - - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - if err := os.WriteFile(jsonlPath, []byte(`{"id":"test-1"}`+"\n"), 0644); err != nil { - _ = os.Chdir(originalWd) - t.Fatalf("failed to write issues.jsonl: %v", err) - } - - // Create initial commit - _ = exec.Command("git", "add", ".beads").Run() - if err := exec.Command("git", "commit", "-m", "initial").Run(); err != nil { - _ = os.Chdir(originalWd) - t.Fatalf("failed to create initial commit: %v", err) - } - - cleanup = func() { - _ = os.Chdir(originalWd) - git.ResetCaches() - beads.ResetCaches() - } - - return tmpDir, cleanup -} - -// setupRedirectedBeadsRepo creates two git repos: source with redirect, target with actual .beads. -// Returns source path, target path, and cleanup function. -func setupRedirectedBeadsRepo(t *testing.T) (sourcePath, targetPath string, cleanup func()) { - t.Helper() - - baseDir := t.TempDir() - originalWd, err := os.Getwd() - if err != nil { - t.Fatalf("failed to get working directory: %v", err) - } - - // Create target repo with actual .beads - targetPath = filepath.Join(baseDir, "target") - if err := os.MkdirAll(targetPath, 0755); err != nil { - t.Fatalf("failed to create target directory: %v", err) - } - - targetBeadsDir := filepath.Join(targetPath, ".beads") - if err := os.MkdirAll(targetBeadsDir, 0755); err != nil { - t.Fatalf("failed to create target .beads directory: %v", err) - } - - // Copy cached git template into target (bd-ktng optimization) - initGitTemplate() - if gitTemplateErr != nil { - t.Fatalf("git template init failed: %v", gitTemplateErr) - } - if err := copyGitDir(gitTemplateDir, targetPath); err != nil { - t.Fatalf("failed to copy git template to target: %v", err) - } - - // Write issues.jsonl in target - jsonlPath := filepath.Join(targetBeadsDir, "issues.jsonl") - if err := os.WriteFile(jsonlPath, []byte(`{"id":"test-1"}`+"\n"), 0644); err != nil { - t.Fatalf("failed to write issues.jsonl: %v", err) - } - - // Commit in target - cmd := exec.Command("git", "add", ".beads") - cmd.Dir = targetPath - _ = cmd.Run() - - cmd = exec.Command("git", "commit", "-m", "initial") - cmd.Dir = targetPath - if err := cmd.Run(); err != nil { - t.Fatalf("failed to create initial commit in target: %v", err) - } - - // Create source repo with redirect - sourcePath = filepath.Join(baseDir, "source") - if err := os.MkdirAll(sourcePath, 0755); err != nil { - t.Fatalf("failed to create source directory: %v", err) - } - - sourceBeadsDir := filepath.Join(sourcePath, ".beads") - if err := os.MkdirAll(sourceBeadsDir, 0755); err != nil { - t.Fatalf("failed to create source .beads directory: %v", err) - } - - // Write redirect file pointing to target - redirectPath := filepath.Join(sourceBeadsDir, "redirect") - // Use relative path: ../target/.beads - if err := os.WriteFile(redirectPath, []byte("../target/.beads\n"), 0644); err != nil { - t.Fatalf("failed to write redirect file: %v", err) - } - - // Copy cached git template into source (bd-ktng optimization) - if err := copyGitDir(gitTemplateDir, sourcePath); err != nil { - t.Fatalf("failed to copy git template to source: %v", err) - } - - // Commit redirect in source - cmd = exec.Command("git", "add", ".beads") - cmd.Dir = sourcePath - _ = cmd.Run() - - cmd = exec.Command("git", "commit", "-m", "initial with redirect") - cmd.Dir = sourcePath - if err := cmd.Run(); err != nil { - t.Fatalf("failed to create initial commit in source: %v", err) - } - - // Change to source directory - if err := os.Chdir(sourcePath); err != nil { - t.Fatalf("failed to change to source directory: %v", err) - } - git.ResetCaches() - beads.ResetCaches() - - cleanup = func() { - _ = os.Chdir(originalWd) - git.ResetCaches() - beads.ResetCaches() - } - - return sourcePath, targetPath, cleanup -} - -func TestGitHasBeadsChanges_NoChanges(t *testing.T) { - ctx := context.Background() - _, cleanup := setupGitRepoWithBeads(t) - defer cleanup() - - hasChanges, err := gitHasBeadsChanges(ctx) - if err != nil { - t.Fatalf("gitHasBeadsChanges() error = %v", err) - } - if hasChanges { - t.Error("expected no changes for clean repo") - } -} - -func TestGitHasBeadsChanges_WithChanges(t *testing.T) { - ctx := context.Background() - repoPath, cleanup := setupGitRepoWithBeads(t) - defer cleanup() - - // Modify the issues.jsonl file - jsonlPath := filepath.Join(repoPath, ".beads", "issues.jsonl") - if err := os.WriteFile(jsonlPath, []byte(`{"id":"test-2"}`+"\n"), 0644); err != nil { - t.Fatalf("failed to modify issues.jsonl: %v", err) - } - - hasChanges, err := gitHasBeadsChanges(ctx) - if err != nil { - t.Fatalf("gitHasBeadsChanges() error = %v", err) - } - if !hasChanges { - t.Error("expected changes for modified file") - } -} - -func TestGitHasBeadsChanges_WithRedirect_NoChanges(t *testing.T) { - ctx := context.Background() - sourcePath, _, cleanup := setupRedirectedBeadsRepo(t) - defer cleanup() - - // Set BEADS_DIR to point to source's .beads (which has the redirect) - oldBeadsDir := os.Getenv("BEADS_DIR") - os.Setenv("BEADS_DIR", filepath.Join(sourcePath, ".beads")) - defer os.Setenv("BEADS_DIR", oldBeadsDir) - - hasChanges, err := gitHasBeadsChanges(ctx) - if err != nil { - t.Fatalf("gitHasBeadsChanges() error = %v", err) - } - if hasChanges { - t.Error("expected no changes for clean redirected repo") - } -} - -func TestGitHasBeadsChanges_WithRedirect_WithChanges(t *testing.T) { - ctx := context.Background() - sourcePath, targetPath, cleanup := setupRedirectedBeadsRepo(t) - defer cleanup() - - // Set BEADS_DIR to point to source's .beads (which has the redirect) - oldBeadsDir := os.Getenv("BEADS_DIR") - os.Setenv("BEADS_DIR", filepath.Join(sourcePath, ".beads")) - defer os.Setenv("BEADS_DIR", oldBeadsDir) - - // Modify the issues.jsonl file in target (where actual beads is) - jsonlPath := filepath.Join(targetPath, ".beads", "issues.jsonl") - if err := os.WriteFile(jsonlPath, []byte(`{"id":"test-2"}`+"\n"), 0644); err != nil { - t.Fatalf("failed to modify issues.jsonl: %v", err) - } - - hasChanges, err := gitHasBeadsChanges(ctx) - if err != nil { - t.Fatalf("gitHasBeadsChanges() error = %v", err) - } - if !hasChanges { - t.Error("expected changes for modified file in redirected repo") - } -} - -func TestGitHasUncommittedBeadsChanges_NoChanges(t *testing.T) { - ctx := context.Background() - _, cleanup := setupGitRepoWithBeads(t) - defer cleanup() - - hasChanges, err := gitHasUncommittedBeadsChanges(ctx) - if err != nil { - t.Fatalf("gitHasUncommittedBeadsChanges() error = %v", err) - } - if hasChanges { - t.Error("expected no changes for clean repo") - } -} - -func TestGitHasUncommittedBeadsChanges_WithChanges(t *testing.T) { - ctx := context.Background() - repoPath, cleanup := setupGitRepoWithBeads(t) - defer cleanup() - - // Modify the issues.jsonl file - jsonlPath := filepath.Join(repoPath, ".beads", "issues.jsonl") - if err := os.WriteFile(jsonlPath, []byte(`{"id":"test-2"}`+"\n"), 0644); err != nil { - t.Fatalf("failed to modify issues.jsonl: %v", err) - } - - hasChanges, err := gitHasUncommittedBeadsChanges(ctx) - if err != nil { - t.Fatalf("gitHasUncommittedBeadsChanges() error = %v", err) - } - if !hasChanges { - t.Error("expected changes for modified file") - } -} - -func TestGitHasUncommittedBeadsChanges_WithRedirect_NoChanges(t *testing.T) { - ctx := context.Background() - sourcePath, _, cleanup := setupRedirectedBeadsRepo(t) - defer cleanup() - - // Set BEADS_DIR to point to source's .beads (which has the redirect) - oldBeadsDir := os.Getenv("BEADS_DIR") - os.Setenv("BEADS_DIR", filepath.Join(sourcePath, ".beads")) - defer os.Setenv("BEADS_DIR", oldBeadsDir) - - hasChanges, err := gitHasUncommittedBeadsChanges(ctx) - if err != nil { - t.Fatalf("gitHasUncommittedBeadsChanges() error = %v", err) - } - if hasChanges { - t.Error("expected no changes for clean redirected repo") - } -} - -func TestGitHasUncommittedBeadsChanges_WithRedirect_WithChanges(t *testing.T) { - ctx := context.Background() - sourcePath, targetPath, cleanup := setupRedirectedBeadsRepo(t) - defer cleanup() - - // Set BEADS_DIR to point to source's .beads (which has the redirect) - oldBeadsDir := os.Getenv("BEADS_DIR") - os.Setenv("BEADS_DIR", filepath.Join(sourcePath, ".beads")) - defer os.Setenv("BEADS_DIR", oldBeadsDir) - - // Modify the issues.jsonl file in target (where actual beads is) - jsonlPath := filepath.Join(targetPath, ".beads", "issues.jsonl") - if err := os.WriteFile(jsonlPath, []byte(`{"id":"test-2"}`+"\n"), 0644); err != nil { - t.Fatalf("failed to modify issues.jsonl: %v", err) - } - - hasChanges, err := gitHasUncommittedBeadsChanges(ctx) - if err != nil { - t.Fatalf("gitHasUncommittedBeadsChanges() error = %v", err) - } - if !hasChanges { - t.Error("expected changes for modified file in redirected repo") - } -} - -func TestParseGitStatusForBeadsChanges(t *testing.T) { - tests := []struct { - name string - status string - expected bool - }{ - // No changes - { - name: "empty status", - status: "", - expected: false, - }, - { - name: "whitespace only", - status: " \n", - expected: false, - }, - - // Modified (should return true) - { - name: "staged modified", - status: "M .beads/issues.jsonl", - expected: true, - }, - { - name: "unstaged modified", - status: " M .beads/issues.jsonl", - expected: true, - }, - { - name: "staged and unstaged modified", - status: "MM .beads/issues.jsonl", - expected: true, - }, - - // Added (should return true) - { - name: "staged added", - status: "A .beads/issues.jsonl", - expected: true, - }, - { - name: "added then modified", - status: "AM .beads/issues.jsonl", - expected: true, - }, - - // Untracked (should return false) - { - name: "untracked file", - status: "?? .beads/issues.jsonl", - expected: false, - }, - - // Deleted (should return false) - { - name: "staged deleted", - status: "D .beads/issues.jsonl", - expected: false, - }, - { - name: "unstaged deleted", - status: " D .beads/issues.jsonl", - expected: false, - }, - - // Edge cases - { - name: "renamed file", - status: "R old.jsonl -> .beads/issues.jsonl", - expected: false, - }, - { - name: "copied file", - status: "C source.jsonl -> .beads/issues.jsonl", - expected: false, - }, - { - name: "status too short", - status: "M", - expected: false, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - result := parseGitStatusForBeadsChanges(tt.status) - if result != tt.expected { - t.Errorf("parseGitStatusForBeadsChanges(%q) = %v, want %v", - tt.status, result, tt.expected) - } - }) - } -} - -// TestGitBranchHasUpstream tests the gitBranchHasUpstream function -// which checks if a specific branch (not current HEAD) has upstream configured. -// This is critical for jj/jujutsu compatibility where HEAD is always detached -// but the sync-branch may have proper upstream tracking. -func TestGitBranchHasUpstream(t *testing.T) { - // Create temp directory for test repos - tmpDir, err := os.MkdirTemp("", "beads-upstream-test-*") - if err != nil { - t.Fatalf("Failed to create temp dir: %v", err) - } - defer os.RemoveAll(tmpDir) - - // Create a bare "remote" repo - remoteDir := filepath.Join(tmpDir, "remote.git") - if err := exec.Command("git", "init", "--bare", remoteDir).Run(); err != nil { - t.Fatalf("Failed to create bare repo: %v", err) - } - - // Create local repo using cached git template (bd-ktng optimization) - localDir := filepath.Join(tmpDir, "local") - if err := os.MkdirAll(localDir, 0755); err != nil { - t.Fatalf("Failed to create local dir: %v", err) - } - initGitTemplate() - if gitTemplateErr != nil { - t.Fatalf("git template init failed: %v", gitTemplateErr) - } - if err := copyGitDir(gitTemplateDir, localDir); err != nil { - t.Fatalf("failed to copy git template: %v", err) - } - cmds := [][]string{ - {"git", "remote", "add", "origin", remoteDir}, - } - for _, args := range cmds { - cmd := exec.Command(args[0], args[1:]...) - cmd.Dir = localDir - if out, err := cmd.CombinedOutput(); err != nil { - t.Fatalf("Failed to run %v: %v\n%s", args, err, out) - } - } - - // Create .beads directory (required for RepoContext) - beadsDir := filepath.Join(localDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("Failed to create .beads dir: %v", err) - } - if err := os.WriteFile(filepath.Join(beadsDir, "issues.jsonl"), []byte{}, 0644); err != nil { - t.Fatalf("Failed to write issues.jsonl: %v", err) - } - - // Create initial commit on main - testFile := filepath.Join(localDir, "test.txt") - if err := os.WriteFile(testFile, []byte("test"), 0644); err != nil { - t.Fatalf("Failed to create test file: %v", err) - } - cmds = [][]string{ - {"git", "add", "."}, - {"git", "commit", "-m", "initial"}, - {"git", "push", "-u", "origin", "main"}, - } - for _, args := range cmds { - cmd := exec.Command(args[0], args[1:]...) - cmd.Dir = localDir - if out, err := cmd.CombinedOutput(); err != nil { - t.Fatalf("Failed to run %v: %v\n%s", args, err, out) - } - } - - // Create beads-sync branch with upstream - cmds = [][]string{ - {"git", "checkout", "-b", "beads-sync"}, - {"git", "push", "-u", "origin", "beads-sync"}, - } - for _, args := range cmds { - cmd := exec.Command(args[0], args[1:]...) - cmd.Dir = localDir - if out, err := cmd.CombinedOutput(); err != nil { - t.Fatalf("Failed to run %v: %v\n%s", args, err, out) - } - } - - // Save current dir and change to local repo - origDir, _ := os.Getwd() - if err := os.Chdir(localDir); err != nil { - t.Fatalf("Failed to chdir: %v", err) - } - // Reset caches after changing directory so RepoContext uses this repo - git.ResetCaches() - beads.ResetCaches() - defer func() { - os.Chdir(origDir) - git.ResetCaches() - beads.ResetCaches() - }() - - // Test 1: beads-sync branch should have upstream - t.Run("branch with upstream returns true", func(t *testing.T) { - if !gitBranchHasUpstream("beads-sync") { - t.Error("gitBranchHasUpstream('beads-sync') = false, want true") - } - }) - - // Test 2: non-existent branch should return false - t.Run("non-existent branch returns false", func(t *testing.T) { - if gitBranchHasUpstream("no-such-branch") { - t.Error("gitBranchHasUpstream('no-such-branch') = true, want false") - } - }) - - // Test 3: Simulate jj detached HEAD - beads-sync should still work - t.Run("works with detached HEAD (jj scenario)", func(t *testing.T) { - // Detach HEAD (simulating jj's behavior) - cmd := exec.Command("git", "checkout", "--detach", "HEAD") - cmd.Dir = localDir - if out, err := cmd.CombinedOutput(); err != nil { - t.Fatalf("Failed to detach HEAD: %v\n%s", err, out) - } - - // gitHasUpstream() should fail (detached HEAD) - if gitHasUpstream() { - t.Error("gitHasUpstream() = true with detached HEAD, want false") - } - - // But gitBranchHasUpstream("beads-sync") should still work - if !gitBranchHasUpstream("beads-sync") { - t.Error("gitBranchHasUpstream('beads-sync') = false with detached HEAD, want true") - } - }) - - // Test 4: branch without upstream should return false - t.Run("branch without upstream returns false", func(t *testing.T) { - // Create a local-only branch (no upstream) - cmd := exec.Command("git", "checkout", "-b", "local-only") - cmd.Dir = localDir - if out, err := cmd.CombinedOutput(); err != nil { - t.Fatalf("Failed to create local branch: %v\n%s", err, out) - } - - if gitBranchHasUpstream("local-only") { - t.Error("gitBranchHasUpstream('local-only') = true, want false (no upstream)") - } - }) -} - -// TestGetCurrentBranchOrHEAD tests getCurrentBranchOrHEAD which returns "HEAD" -// when in detached HEAD state (e.g., jj/jujutsu) instead of failing. -// TestConfigPreservedDuringSync is a regression test for GH#1100. -// It verifies that config.yaml in .beads/ is not overwritten during sync operations. -// The bug was caused by restoreBeadsDirFromBranch() which ran: -// -// git checkout HEAD -- .beads/ -// -// This restored the ENTIRE .beads/ directory, including user's uncommitted config.yaml. -// The function was removed in PR #918 (pull-first refactor). -// This test ensures similar restoration logic is never reintroduced. -func TestConfigPreservedDuringSync(t *testing.T) { - if testing.Short() { - t.Skip("Skipping integration test in short mode") - } - - t.Run("uncommitted config.yaml not overwritten by git operations", func(t *testing.T) { - // Setup: Create git repo with .beads directory - repoPath, cleanup := setupGitRepoWithBeads(t) - defer cleanup() - - beadsDir := filepath.Join(repoPath, ".beads") - - // Create config.yaml and commit it - configPath := filepath.Join(beadsDir, "config.yaml") - originalContent := "sync:\n branch: beads-sync\n" - if err := os.WriteFile(configPath, []byte(originalContent), 0644); err != nil { - t.Fatalf("failed to write config.yaml: %v", err) - } - - // Commit the config - _ = exec.Command("git", "add", ".beads/config.yaml").Run() - if err := exec.Command("git", "commit", "-m", "add config").Run(); err != nil { - t.Fatalf("failed to commit config: %v", err) - } - - // Now modify config.yaml with UNCOMMITTED changes (the bug scenario) - modifiedContent := originalContent + "# User's uncommitted customization\ntest-marker: preserved\n" - if err := os.WriteFile(configPath, []byte(modifiedContent), 0644); err != nil { - t.Fatalf("failed to modify config.yaml: %v", err) - } - - // Verify the modification exists before any operations - beforeSync, err := os.ReadFile(configPath) - if err != nil { - t.Fatalf("failed to read config.yaml: %v", err) - } - if !strings.Contains(string(beforeSync), "test-marker: preserved") { - t.Fatal("expected test-marker in config before operations") - } - - // Simulate what the old buggy code did: git checkout HEAD -- .beads/ - // This should NOT happen during normal sync, but we test that IF it did, - // it would restore committed state (losing uncommitted changes). - // The fact that no code calls this anymore is the fix. - - // Verify config.yaml still has uncommitted changes - // (This passes because nothing calls restoreBeadsDirFromBranch anymore) - afterContent, err := os.ReadFile(configPath) - if err != nil { - t.Fatalf("failed to read config.yaml after operations: %v", err) - } - - if !strings.Contains(string(afterContent), "test-marker: preserved") { - t.Errorf("REGRESSION: uncommitted config.yaml changes were lost!\n"+ - "Before: %s\nAfter: %s", beforeSync, afterContent) - } - - // Also verify that git status shows the file as modified (uncommitted) - cmd := exec.Command("git", "status", "--porcelain", ".beads/config.yaml") - output, err := cmd.Output() - if err != nil { - t.Fatalf("git status failed: %v", err) - } - - // Should show " M" (modified, unstaged) - if !strings.Contains(string(output), "M") { - t.Errorf("expected config.yaml to show as modified in git status, got: %q", output) - } - }) - - t.Run("restoreBeadsDirFromBranch function does not exist", func(t *testing.T) { - // This test documents that the function was intentionally removed. - // If someone adds it back, they should also update this test with justification. - - // Read the sync_git.go source file - syncGitPath := filepath.Join(getProjectRoot(t), "cmd", "bd", "sync_git.go") - content, err := os.ReadFile(syncGitPath) - if err != nil { - t.Fatalf("failed to read sync_git.go: %v", err) - } - - // The function should NOT exist - if strings.Contains(string(content), "func restoreBeadsDirFromBranch") { - t.Error("REGRESSION: restoreBeadsDirFromBranch function was reintroduced!\n" + - "This function caused GH#1100 by restoring entire .beads/ directory.\n" + - "If you need this functionality, use selective restoration that excludes config.yaml.") - } - }) -} - -// getProjectRoot returns the project root directory for test file access. -// Uses runtime.Caller to find the source file location, which is immune to -// os.Chdir side effects from other subtests. -func getProjectRoot(t *testing.T) string { - t.Helper() - _, thisFile, _, ok := runtime.Caller(0) - if !ok { - t.Fatal("failed to get current file path via runtime.Caller") - } - // thisFile is cmd/bd/sync_git_test.go; walk up to find go.mod - dir := filepath.Dir(thisFile) - for { - if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil { - return dir - } - parent := filepath.Dir(dir) - if parent == dir { - t.Fatal("could not find project root (go.mod)") - } - dir = parent - } -} - -func TestGetCurrentBranchOrHEAD(t *testing.T) { - ctx := context.Background() - - // Create temp directory for test repo - tmpDir, err := os.MkdirTemp("", "beads-branch-test-*") - if err != nil { - t.Fatalf("Failed to create temp dir: %v", err) - } - defer os.RemoveAll(tmpDir) - - // Initialize git repo - cmds := [][]string{ - {"git", "init", "-b", "main"}, - {"git", "config", "user.email", "test@test.com"}, - {"git", "config", "user.name", "Test"}, - } - for _, args := range cmds { - cmd := exec.Command(args[0], args[1:]...) - cmd.Dir = tmpDir - if out, err := cmd.CombinedOutput(); err != nil { - t.Fatalf("Failed to run %v: %v\n%s", args, err, out) - } - } - - // Create initial commit - testFile := filepath.Join(tmpDir, "test.txt") - if err := os.WriteFile(testFile, []byte("test"), 0644); err != nil { - t.Fatalf("Failed to create test file: %v", err) - } - cmds = [][]string{ - {"git", "add", "test.txt"}, - {"git", "commit", "-m", "initial"}, - } - for _, args := range cmds { - cmd := exec.Command(args[0], args[1:]...) - cmd.Dir = tmpDir - if out, err := cmd.CombinedOutput(); err != nil { - t.Fatalf("Failed to run %v: %v\n%s", args, err, out) - } - } - - // Save current dir and change to test repo - origDir, _ := os.Getwd() - if err := os.Chdir(tmpDir); err != nil { - t.Fatalf("Failed to chdir: %v", err) - } - defer os.Chdir(origDir) - - // Test 1: Normal branch returns branch name - t.Run("returns branch name when on branch", func(t *testing.T) { - branch := getCurrentBranchOrHEAD(ctx) - if branch != "main" { - t.Errorf("getCurrentBranchOrHEAD() = %q, want %q", branch, "main") - } - }) - - // Test 2: Detached HEAD returns "HEAD" - t.Run("returns HEAD when detached", func(t *testing.T) { - // Detach HEAD - cmd := exec.Command("git", "checkout", "--detach", "HEAD") - cmd.Dir = tmpDir - if out, err := cmd.CombinedOutput(); err != nil { - t.Fatalf("Failed to detach HEAD: %v\n%s", err, out) - } - - branch := getCurrentBranchOrHEAD(ctx) - if branch != "HEAD" { - t.Errorf("getCurrentBranchOrHEAD() = %q, want %q", branch, "HEAD") - } - }) -} diff --git a/cmd/bd/sync_helpers.go b/cmd/bd/sync_helpers.go index 4eacf85ad..10814d2f4 100644 --- a/cmd/bd/sync_helpers.go +++ b/cmd/bd/sync_helpers.go @@ -54,15 +54,6 @@ func sanitizeMetadataKey(key string) string { return strings.ReplaceAll(key, ":", "_") } -// getDebounceDuration returns the configured flush debounce duration. -func getDebounceDuration() time.Duration { - duration := config.GetDuration("flush-debounce") - if duration == 0 { - return 5 * time.Second - } - return duration -} - // exportToJSONLWithStore exports issues to JSONL using the provided store. // If multi-repo mode is configured, routes issues to their respective JSONL files. // Otherwise, exports to a single JSONL file. @@ -218,6 +209,67 @@ func importToJSONLWithStore(ctx context.Context, store *dolt.DoltStore, jsonlPat return err } +// exportToJSONL exports the current database state to the JSONL file. +// Delegates to exportToJSONLWithStore using the global store. +func exportToJSONL(ctx context.Context, jsonlPath string) error { + if err := ensureStoreActive(); err != nil { + return fmt.Errorf("activating store: %w", err) + } + if err := exportToJSONLWithStore(ctx, store, jsonlPath); err != nil { + return err + } + repoKey := getRepoKeyForPath(jsonlPath) + updateExportMetadata(ctx, store, jsonlPath, slog.Default(), repoKey) + return nil +} + +// importFromJSONL imports issues from a JSONL file into the database. +func importFromJSONL(ctx context.Context, jsonlPath string) error { + if err := ensureStoreActive(); err != nil { + return fmt.Errorf("activating store: %w", err) + } + return importToJSONLWithStore(ctx, store, jsonlPath) +} + +// loadIssuesFromJSONL reads a JSONL file and returns the parsed issues. +func loadIssuesFromJSONL(jsonlPath string) ([]*types.Issue, error) { + file, err := os.Open(jsonlPath) // #nosec G304 - controlled path + if err != nil { + if os.IsNotExist(err) { + return nil, nil + } + return nil, fmt.Errorf("opening JSONL: %w", err) + } + defer file.Close() + + var issues []*types.Issue + scanner := bufio.NewScanner(file) + const maxScannerBuffer = 1024 * 1024 // 1MB + scanner.Buffer(make([]byte, 0, maxScannerBuffer), maxScannerBuffer) + + lineNum := 0 + for scanner.Scan() { + lineNum++ + line := scanner.Text() + if line == "" { + continue + } + + var issue types.Issue + if err := json.Unmarshal([]byte(line), &issue); err != nil { + fmt.Fprintf(os.Stderr, "Warning: failed to parse JSONL line %d: %v\n", lineNum, err) + continue + } + issues = append(issues, &issue) + } + + if err := scanner.Err(); err != nil { + return nil, fmt.Errorf("reading JSONL: %w", err) + } + + return issues, nil +} + // updateExportMetadata updates jsonl_content_hash and related metadata after a successful export. func updateExportMetadata(ctx context.Context, store *dolt.DoltStore, jsonlPath string, log *slog.Logger, keySuffix string) { if keySuffix != "" { diff --git a/cmd/bd/sync_helpers_more_test.go b/cmd/bd/sync_helpers_more_test.go deleted file mode 100644 index 8e5ec64de..000000000 --- a/cmd/bd/sync_helpers_more_test.go +++ /dev/null @@ -1,101 +0,0 @@ -//go:build cgo - -package main - -import ( - "context" - "os" - "os/exec" - "path/filepath" - "strings" - "testing" - - "github.com/steveyegge/beads/internal/config" -) - -func TestBuildGitCommitArgs_ConfigOptions(t *testing.T) { - initConfigForTest(t) - config.Set("git.author", "Test User ") - config.Set("git.no-gpg-sign", true) - - args := buildGitCommitArgs("/repo", "hello", "--", ".beads") - joined := strings.Join(args, " ") - if !strings.Contains(joined, "--author") { - t.Fatalf("expected --author in args: %v", args) - } - if !strings.Contains(joined, "--no-gpg-sign") { - t.Fatalf("expected --no-gpg-sign in args: %v", args) - } - if !strings.Contains(joined, "-m hello") { - t.Fatalf("expected message in args: %v", args) - } - // buildGitCommitArgs includes -C for raw exec.Command - if !strings.HasPrefix(joined, "-C /repo commit") { - t.Fatalf("expected -C /repo prefix in args: %v", args) - } -} - -func TestBuildCommitArgs_ForRepoContext(t *testing.T) { - // buildCommitArgs is for use with RepoContext.GitCmd() which sets cmd.Dir, - // so it should NOT include the -C flag. - initConfigForTest(t) - config.Set("git.author", "Test User ") - config.Set("git.no-gpg-sign", true) - - args := buildCommitArgs("hello", "--", ".beads") - joined := strings.Join(args, " ") - - // Should start with "commit", not "-C" - if !strings.HasPrefix(joined, "commit") { - t.Fatalf("expected to start with 'commit', got: %v", args) - } - if strings.Contains(joined, "-C") { - t.Fatalf("buildCommitArgs should NOT contain -C (RepoContext sets cmd.Dir): %v", args) - } - if !strings.Contains(joined, "--author") { - t.Fatalf("expected --author in args: %v", args) - } - if !strings.Contains(joined, "--no-gpg-sign") { - t.Fatalf("expected --no-gpg-sign in args: %v", args) - } - if !strings.Contains(joined, "-m hello") { - t.Fatalf("expected message in args: %v", args) - } -} - -func TestGitCommitBeadsDir_PathspecDoesNotCommitOtherStagedFiles(t *testing.T) { - _, cleanup := setupGitRepo(t) - defer cleanup() - - initConfigForTest(t) - - if err := os.MkdirAll(".beads", 0o755); err != nil { - t.Fatalf("MkdirAll: %v", err) - } - - // Stage an unrelated file before running gitCommitBeadsDir. - if err := os.WriteFile("other.txt", []byte("x\n"), 0o600); err != nil { - t.Fatalf("WriteFile other: %v", err) - } - _ = exec.Command("git", "add", "other.txt").Run() - - // Create a beads sync file to commit. - issuesPath := filepath.Join(".beads", "issues.jsonl") - if err := os.WriteFile(issuesPath, []byte("{\"id\":\"test-1\"}\n"), 0o600); err != nil { - t.Fatalf("WriteFile issues: %v", err) - } - - ctx := context.Background() - if err := gitCommitBeadsDir(ctx, "beads commit"); err != nil { - t.Fatalf("gitCommitBeadsDir: %v", err) - } - - // other.txt should still be staged after the beads-only commit. - out, err := exec.Command("git", "diff", "--cached", "--name-only").CombinedOutput() - if err != nil { - t.Fatalf("git diff --cached: %v\n%s", err, out) - } - if strings.TrimSpace(string(out)) != "other.txt" { - t.Fatalf("expected other.txt still staged, got: %q", out) - } -} diff --git a/cmd/bd/sync_local_only_test.go b/cmd/bd/sync_local_only_test.go deleted file mode 100644 index 583b0b37d..000000000 --- a/cmd/bd/sync_local_only_test.go +++ /dev/null @@ -1,119 +0,0 @@ -//go:build cgo && integration - -package main - -import ( - "context" - "os" - "os/exec" - "path/filepath" - "testing" -) - -// TestLocalOnlyMode tests that daemon works with local git repos (no remote) -func TestLocalOnlyMode(t *testing.T) { - if testing.Short() { - t.Skip("Skipping integration test in short mode") - } - - // Create temp directory for local-only repo - tempDir := t.TempDir() - - // Initialize local git repo without remote - runGitCmd(t, tempDir, "init") - runGitCmd(t, tempDir, "config", "user.email", "test@example.com") - runGitCmd(t, tempDir, "config", "user.name", "Test User") - - // Change to temp directory so git commands run in the test repo - t.Chdir(tempDir) - - // Verify no remote exists - cmd := exec.Command("git", "remote") - output, err := cmd.Output() - if err != nil { - t.Fatalf("Failed to check git remotes: %v", err) - } - if len(output) > 0 { - t.Fatalf("Expected no remotes, got: %s", output) - } - - ctx := context.Background() - - // Test hasGitRemote returns false - if hasGitRemote(ctx) { - t.Error("Expected hasGitRemote to return false for local-only repo") - } - - // Test gitPull returns nil (no error) - if err := gitPull(ctx, ""); err != nil { - t.Errorf("gitPull should gracefully skip when no remote, got error: %v", err) - } - - // Test gitPush returns nil (no error) - if err := gitPush(ctx, ""); err != nil { - t.Errorf("gitPush should gracefully skip when no remote, got error: %v", err) - } - - // Create a dummy JSONL file to commit - beadsDir := filepath.Join(tempDir, ".beads") - if err := os.MkdirAll(beadsDir, 0750); err != nil { - t.Fatalf("Failed to create .beads dir: %v", err) - } - - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - if err := os.WriteFile(jsonlPath, []byte(`{"id":"test-1","title":"Test"}`+"\n"), 0644); err != nil { - t.Fatalf("Failed to write JSONL: %v", err) - } - - // Test gitCommit works (local commits should work fine) - runGitCmd(t, tempDir, "add", ".beads") - if err := gitCommit(ctx, jsonlPath, "Test commit"); err != nil { - t.Errorf("gitCommit should work in local-only mode, got error: %v", err) - } - - // Verify commit was created - cmd = exec.Command("git", "log", "--oneline") - output, err = cmd.Output() - if err != nil { - t.Fatalf("Failed to check git log: %v", err) - } - if len(output) == 0 { - t.Error("Expected at least one commit in git log") - } -} - -// TestWithRemote verifies hasGitRemote detects remotes correctly -func TestWithRemote(t *testing.T) { - if testing.Short() { - t.Skip("Skipping integration test in short mode") - } - - // Create temp directories - tempDir := t.TempDir() - remoteDir := filepath.Join(tempDir, "remote") - cloneDir := filepath.Join(tempDir, "clone") - - // Create bare remote - if err := os.MkdirAll(remoteDir, 0750); err != nil { - t.Fatalf("Failed to create remote dir: %v", err) - } - runGitCmd(t, remoteDir, "init", "--bare") - - // Clone it - runGitCmd(t, tempDir, "clone", remoteDir, cloneDir) - - // Change to clone directory - t.Chdir(cloneDir) - - ctx := context.Background() - - // Test hasGitRemote returns true - if !hasGitRemote(ctx) { - t.Error("Expected hasGitRemote to return true when origin exists") - } - - // Verify git pull doesn't error (even with empty remote) - // Note: pull might fail with "couldn't find remote ref", but that's different - // from the fatal "'origin' does not appear to be a git repository" error - _ = gitPull(ctx, "") // Just verify it doesn't panic -} diff --git a/cmd/bd/sync_manual.go b/cmd/bd/sync_manual.go deleted file mode 100644 index 96cf7fc09..000000000 --- a/cmd/bd/sync_manual.go +++ /dev/null @@ -1,398 +0,0 @@ -package main - -import ( - "bufio" - "encoding/json" - "fmt" - "io" - "os" - "strings" - "unicode/utf8" - - "github.com/steveyegge/beads/internal/beads" - "github.com/steveyegge/beads/internal/ui" -) - -// InteractiveConflict represents a conflict to be resolved interactively -type InteractiveConflict struct { - IssueID string - Local *beads.Issue - Remote *beads.Issue - Base *beads.Issue // May be nil for first sync -} - -// InteractiveResolution represents the user's choice for a conflict -type InteractiveResolution struct { - Choice string // "local", "remote", "merged", "skip", "quit", "accept-all" - Issue *beads.Issue // The resolved issue (nil if skipped/quit) -} - -// resolveConflictsInteractively handles manual conflict resolution with user prompts. -// Returns resolved issues and the count of skipped conflicts. -func resolveConflictsInteractively(conflicts []InteractiveConflict) ([]*beads.Issue, int, error) { - // Check if we're in a terminal - if !ui.IsTerminal() { - return nil, 0, fmt.Errorf("manual conflict resolution requires an interactive terminal") - } - - reader := bufio.NewReader(os.Stdin) - var resolved []*beads.Issue - skipped := 0 - - fmt.Printf("\n%s Manual Conflict Resolution\n", ui.RenderAccent("🔧")) - fmt.Printf("Found %d conflict(s) requiring manual resolution.\n\n", len(conflicts)) - - for i, conflict := range conflicts { - fmt.Printf("%s Conflict %d/%d: %s\n", ui.RenderAccent("━━━"), i+1, len(conflicts), conflict.IssueID) - fmt.Println() - - // Display the diff - displayConflictDiff(conflict) - - // Prompt for choice - resolution, err := promptConflictResolution(reader, conflict) - if err != nil { - return nil, 0, fmt.Errorf("reading user input: %w", err) - } - - switch resolution.Choice { - case "quit": - // Quit - skip all remaining conflicts - remaining := len(conflicts) - i - skipped += remaining - fmt.Printf(" %s Quit - skipping %d remaining conflict(s)\n\n", ui.RenderMuted("⏹"), remaining) - return resolved, skipped, nil - - case "accept-all": - // Auto-merge all remaining conflicts - fmt.Printf(" %s Auto-merging %d remaining conflict(s)...\n", ui.RenderAccent("⚡"), len(conflicts)-i) - for j := i; j < len(conflicts); j++ { - c := conflicts[j] - if c.Local != nil && c.Remote != nil { - merged, _ := mergeFieldLevel(c.Base, c.Local, c.Remote) - resolved = append(resolved, merged) - } else if c.Local != nil { - resolved = append(resolved, c.Local) - } else if c.Remote != nil { - resolved = append(resolved, c.Remote) - } - } - fmt.Printf(" %s Done\n\n", ui.RenderPass("✓")) - return resolved, skipped, nil - - case "skip": - skipped++ - fmt.Printf(" %s Skipped (will keep local, conflict remains)\n\n", ui.RenderMuted("⏭")) - - case "local": - resolved = append(resolved, conflict.Local) - fmt.Printf(" %s Kept local version\n\n", ui.RenderPass("✓")) - - case "remote": - resolved = append(resolved, conflict.Remote) - fmt.Printf(" %s Kept remote version\n\n", ui.RenderPass("✓")) - - case "merged": - resolved = append(resolved, resolution.Issue) - fmt.Printf(" %s Used field-level merge\n\n", ui.RenderPass("✓")) - } - } - - return resolved, skipped, nil -} - -// displayConflictDiff shows the differences between local and remote versions -func displayConflictDiff(conflict InteractiveConflict) { - local := conflict.Local - remote := conflict.Remote - - if local == nil && remote == nil { - fmt.Println(" Both versions are nil (should not happen)") - return - } - - if local == nil { - fmt.Printf(" %s Local: (deleted)\n", ui.RenderMuted("LOCAL")) - fmt.Printf(" %s Remote: exists\n", ui.RenderAccent("REMOTE")) - displayIssueSummary(remote, " ") - return - } - - if remote == nil { - fmt.Printf(" %s Local: exists\n", ui.RenderAccent("LOCAL")) - displayIssueSummary(local, " ") - fmt.Printf(" %s Remote: (deleted)\n", ui.RenderMuted("REMOTE")) - return - } - - // Both exist - show field-by-field diff - fmt.Printf(" %s\n", ui.RenderMuted("─── Field Differences ───")) - fmt.Println() - - // Title - if local.Title != remote.Title { - fmt.Printf(" %s\n", ui.RenderAccent("title:")) - fmt.Printf(" %s %s\n", ui.RenderMuted("local:"), local.Title) - fmt.Printf(" %s %s\n", ui.RenderAccent("remote:"), remote.Title) - } - - // Status - if local.Status != remote.Status { - fmt.Printf(" %s\n", ui.RenderAccent("status:")) - fmt.Printf(" %s %s\n", ui.RenderMuted("local:"), local.Status) - fmt.Printf(" %s %s\n", ui.RenderAccent("remote:"), remote.Status) - } - - // Priority - if local.Priority != remote.Priority { - fmt.Printf(" %s\n", ui.RenderAccent("priority:")) - fmt.Printf(" %s P%d\n", ui.RenderMuted("local:"), local.Priority) - fmt.Printf(" %s P%d\n", ui.RenderAccent("remote:"), remote.Priority) - } - - // Assignee - if local.Assignee != remote.Assignee { - fmt.Printf(" %s\n", ui.RenderAccent("assignee:")) - fmt.Printf(" %s %s\n", ui.RenderMuted("local:"), valueOrNone(local.Assignee)) - fmt.Printf(" %s %s\n", ui.RenderAccent("remote:"), valueOrNone(remote.Assignee)) - } - - // Description (show truncated if different) - if local.Description != remote.Description { - fmt.Printf(" %s\n", ui.RenderAccent("description:")) - fmt.Printf(" %s %s\n", ui.RenderMuted("local:"), truncateText(local.Description)) - fmt.Printf(" %s %s\n", ui.RenderAccent("remote:"), truncateText(remote.Description)) - } - - // Notes (show truncated if different) - if local.Notes != remote.Notes { - fmt.Printf(" %s\n", ui.RenderAccent("notes:")) - fmt.Printf(" %s %s\n", ui.RenderMuted("local:"), truncateText(local.Notes)) - fmt.Printf(" %s %s\n", ui.RenderAccent("remote:"), truncateText(remote.Notes)) - } - - // Labels - localLabels := strings.Join(local.Labels, ", ") - remoteLabels := strings.Join(remote.Labels, ", ") - if localLabels != remoteLabels { - fmt.Printf(" %s\n", ui.RenderAccent("labels:")) - fmt.Printf(" %s [%s]\n", ui.RenderMuted("local:"), valueOrNone(localLabels)) - fmt.Printf(" %s [%s]\n", ui.RenderAccent("remote:"), valueOrNone(remoteLabels)) - } - - // Updated timestamps - fmt.Printf(" %s\n", ui.RenderAccent("updated_at:")) - fmt.Printf(" %s %s\n", ui.RenderMuted("local:"), local.UpdatedAt.Format("2006-01-02 15:04:05")) - fmt.Printf(" %s %s\n", ui.RenderAccent("remote:"), remote.UpdatedAt.Format("2006-01-02 15:04:05")) - - // Indicate which is newer - if local.UpdatedAt.After(remote.UpdatedAt) { - fmt.Printf(" %s\n", ui.RenderPass("(local is newer)")) - } else if remote.UpdatedAt.After(local.UpdatedAt) { - fmt.Printf(" %s\n", ui.RenderPass("(remote is newer)")) - } else { - fmt.Printf(" %s\n", ui.RenderMuted("(same timestamp)")) - } - - fmt.Println() -} - -// displayIssueSummary shows a brief summary of an issue -func displayIssueSummary(issue *beads.Issue, indent string) { - if issue == nil { - return - } - fmt.Printf("%stitle: %s\n", indent, issue.Title) - fmt.Printf("%sstatus: %s, priority: P%d\n", indent, issue.Status, issue.Priority) - if issue.Assignee != "" { - fmt.Printf("%sassignee: %s\n", indent, issue.Assignee) - } -} - -// promptConflictResolution asks the user how to resolve a conflict -func promptConflictResolution(reader *bufio.Reader, conflict InteractiveConflict) (InteractiveResolution, error) { - local := conflict.Local - remote := conflict.Remote - - // Build options based on what's available - var options []string - optionMap := make(map[string]string) - - if local != nil { - options = append(options, "l") - optionMap["l"] = "local" - optionMap["local"] = "local" - } - if remote != nil { - options = append(options, "r") - optionMap["r"] = "remote" - optionMap["remote"] = "remote" - } - if local != nil && remote != nil { - options = append(options, "m") - optionMap["m"] = "merged" - optionMap["merge"] = "merged" - optionMap["merged"] = "merged" - } - options = append(options, "s", "a", "q", "d", "?") - optionMap["s"] = "skip" - optionMap["skip"] = "skip" - optionMap["a"] = "accept-all" - optionMap["all"] = "accept-all" - optionMap["q"] = "quit" - optionMap["quit"] = "quit" - optionMap["d"] = "diff" - optionMap["diff"] = "diff" - optionMap["?"] = "help" - optionMap["help"] = "help" - - for { - fmt.Printf(" Choice [%s]: ", strings.Join(options, "/")) - input, err := reader.ReadString('\n') - if err != nil { - if err == io.EOF { - // Treat EOF as quit - return InteractiveResolution{Choice: "quit", Issue: nil}, nil - } - return InteractiveResolution{}, err - } - - choice := strings.TrimSpace(strings.ToLower(input)) - if choice == "" { - // Default to merged if both exist, otherwise keep the one that exists - if local != nil && remote != nil { - choice = "m" - } else if local != nil { - choice = "l" - } else { - choice = "r" - } - } - - action, ok := optionMap[choice] - if !ok { - fmt.Printf(" %s Unknown option '%s'. Type '?' for help.\n", ui.RenderFail("✗"), choice) - continue - } - - switch action { - case "help": - printResolutionHelp(local != nil, remote != nil) - continue - - case "diff": - // Show detailed diff (JSON dump) - showDetailedDiff(conflict) - continue - - case "local": - return InteractiveResolution{Choice: "local", Issue: local}, nil - - case "remote": - return InteractiveResolution{Choice: "remote", Issue: remote}, nil - - case "merged": - // Do field-level merge (same as automatic LWW merge) - merged, _ := mergeFieldLevel(conflict.Base, local, remote) - return InteractiveResolution{Choice: "merged", Issue: merged}, nil - - case "skip": - return InteractiveResolution{Choice: "skip", Issue: nil}, nil - - case "accept-all": - return InteractiveResolution{Choice: "accept-all", Issue: nil}, nil - - case "quit": - return InteractiveResolution{Choice: "quit", Issue: nil}, nil - } - } -} - -// printResolutionHelp shows help for resolution options -func printResolutionHelp(hasLocal, hasRemote bool) { - fmt.Println() - fmt.Println(" Resolution options:") - if hasLocal { - fmt.Println(" l, local - Keep the local version") - } - if hasRemote { - fmt.Println(" r, remote - Keep the remote version") - } - if hasLocal && hasRemote { - fmt.Println(" m, merge - Auto-merge (LWW for scalars, union for collections)") - } - fmt.Println(" s, skip - Skip this conflict (keep local, conflict remains)") - fmt.Println(" a, all - Accept auto-merge for all remaining conflicts") - fmt.Println(" q, quit - Quit and skip all remaining conflicts") - fmt.Println(" d, diff - Show detailed JSON diff") - fmt.Println(" ?, help - Show this help") - fmt.Println() -} - -// showDetailedDiff displays the full JSON of both versions -func showDetailedDiff(conflict InteractiveConflict) { - fmt.Println() - fmt.Printf(" %s\n", ui.RenderMuted("─── Detailed Diff (JSON) ───")) - fmt.Println() - - if conflict.Local != nil { - fmt.Printf(" %s\n", ui.RenderAccent("LOCAL:")) - localJSON, err := json.MarshalIndent(conflict.Local, " ", " ") - if err != nil { - fmt.Printf(" (error marshaling: %v)\n", err) - } else { - fmt.Println(string(localJSON)) - } - fmt.Println() - } else { - fmt.Printf(" %s (deleted)\n", ui.RenderMuted("LOCAL:")) - } - - if conflict.Remote != nil { - fmt.Printf(" %s\n", ui.RenderAccent("REMOTE:")) - remoteJSON, err := json.MarshalIndent(conflict.Remote, " ", " ") - if err != nil { - fmt.Printf(" (error marshaling: %v)\n", err) - } else { - fmt.Println(string(remoteJSON)) - } - fmt.Println() - } else { - fmt.Printf(" %s (deleted)\n", ui.RenderMuted("REMOTE:")) - } -} - -// Helper functions - -func valueOrNone(s string) string { - if s == "" { - return "(none)" - } - return s -} - -const truncateTextMaxLen = 60 - -// truncateText truncates a string to a fixed max length (runes, not bytes) for proper UTF-8 handling. -// Replaces newlines with spaces for single-line display. -func truncateText(s string) string { - if s == "" { - return "(empty)" - } - // Replace newlines with spaces for display - s = strings.ReplaceAll(s, "\n", " ") - s = strings.ReplaceAll(s, "\r", "") - - // Count runes, not bytes, for proper UTF-8 handling - runeCount := utf8.RuneCountInString(s) - if runeCount <= truncateTextMaxLen { - return s - } - - // Truncate by runes - runes := []rune(s) - if truncateTextMaxLen <= 3 { - return "..." - } - return string(runes[:truncateTextMaxLen-3]) + "..." -} diff --git a/cmd/bd/sync_manual_test.go b/cmd/bd/sync_manual_test.go deleted file mode 100644 index d30486ebf..000000000 --- a/cmd/bd/sync_manual_test.go +++ /dev/null @@ -1,338 +0,0 @@ -package main - -import ( - "strings" - "testing" - "time" - - "github.com/steveyegge/beads/internal/beads" -) - -func TestTruncateText(t *testing.T) { - tests := []struct { - name string - input string - want string - }{ - { - name: "empty string", - input: "", - want: "(empty)", - }, - { - name: "short string", - input: "hello", - want: "hello", - }, - { - name: "newlines replaced", - input: "line1\nline2\r\nline3", - want: "line1 line2 line3", - }, - { - name: "truncated at fixed max", - input: strings.Repeat("a", truncateTextMaxLen+10), - want: strings.Repeat("a", truncateTextMaxLen-3) + "...", - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got := truncateText(tt.input) - if got != tt.want { - t.Errorf("truncateText(%q) = %q, want %q", tt.input, got, tt.want) - } - }) - } -} - -func TestValueOrNone(t *testing.T) { - tests := []struct { - input string - want string - }{ - {"", "(none)"}, - {"value", "value"}, - {" ", " "}, - } - - for _, tt := range tests { - got := valueOrNone(tt.input) - if got != tt.want { - t.Errorf("valueOrNone(%q) = %q, want %q", tt.input, got, tt.want) - } - } -} - -func TestInteractiveConflictDisplay(t *testing.T) { - now := time.Now() - earlier := now.Add(-1 * time.Hour) - - // Test that displayConflictDiff doesn't panic for various inputs - tests := []struct { - name string - conflict InteractiveConflict - }{ - { - name: "both exist with differences", - conflict: InteractiveConflict{ - IssueID: "test-1", - Local: &beads.Issue{ - ID: "test-1", - Title: "Local title", - Status: beads.StatusOpen, - Priority: 1, - UpdatedAt: now, - }, - Remote: &beads.Issue{ - ID: "test-1", - Title: "Remote title", - Status: beads.StatusInProgress, - Priority: 2, - UpdatedAt: earlier, - }, - }, - }, - { - name: "local deleted", - conflict: InteractiveConflict{ - IssueID: "test-2", - Local: nil, - Remote: &beads.Issue{ - ID: "test-2", - Title: "Remote only", - Status: beads.StatusOpen, - UpdatedAt: now, - }, - }, - }, - { - name: "remote deleted", - conflict: InteractiveConflict{ - IssueID: "test-3", - Local: &beads.Issue{ - ID: "test-3", - Title: "Local only", - Status: beads.StatusOpen, - UpdatedAt: now, - }, - Remote: nil, - }, - }, - { - name: "same timestamps", - conflict: InteractiveConflict{ - IssueID: "test-4", - Local: &beads.Issue{ - ID: "test-4", - Title: "Same time local", - UpdatedAt: now, - }, - Remote: &beads.Issue{ - ID: "test-4", - Title: "Same time remote", - UpdatedAt: now, - }, - }, - }, - { - name: "with labels", - conflict: InteractiveConflict{ - IssueID: "test-5", - Local: &beads.Issue{ - ID: "test-5", - Title: "Local", - Labels: []string{"bug", "urgent"}, - UpdatedAt: now, - }, - Remote: &beads.Issue{ - ID: "test-5", - Title: "Remote", - Labels: []string{"feature", "low-priority"}, - UpdatedAt: earlier, - }, - }, - }, - { - name: "both nil (edge case)", - conflict: InteractiveConflict{ - IssueID: "test-6", - Local: nil, - Remote: nil, - }, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Just make sure it doesn't panic - displayConflictDiff(tt.conflict) - }) - } -} - -func TestShowDetailedDiff(t *testing.T) { - now := time.Now() - - tests := []struct { - name string - conflict InteractiveConflict - }{ - { - name: "both exist", - conflict: InteractiveConflict{ - IssueID: "test-1", - Local: &beads.Issue{ - ID: "test-1", - Title: "Local", - UpdatedAt: now, - }, - Remote: &beads.Issue{ - ID: "test-1", - Title: "Remote", - UpdatedAt: now, - }, - }, - }, - { - name: "local nil", - conflict: InteractiveConflict{ - IssueID: "test-2", - Local: nil, - Remote: &beads.Issue{ - ID: "test-2", - Title: "Remote", - UpdatedAt: now, - }, - }, - }, - { - name: "remote nil", - conflict: InteractiveConflict{ - IssueID: "test-3", - Local: &beads.Issue{ - ID: "test-3", - Title: "Local", - UpdatedAt: now, - }, - Remote: nil, - }, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Just make sure it doesn't panic - showDetailedDiff(tt.conflict) - }) - } -} - -func TestPrintResolutionHelp(t *testing.T) { - // Test all combinations of hasLocal/hasRemote - tests := []struct { - hasLocal bool - hasRemote bool - }{ - {true, true}, - {true, false}, - {false, true}, - {false, false}, - } - - for _, tt := range tests { - // Just make sure it doesn't panic - printResolutionHelp(tt.hasLocal, tt.hasRemote) - } -} - -func TestDisplayIssueSummary(t *testing.T) { - issue := &beads.Issue{ - ID: "test-1", - Title: "Test issue", - Status: beads.StatusOpen, - Priority: 2, - Assignee: "alice", - } - - // Just make sure it doesn't panic - displayIssueSummary(issue, " ") - displayIssueSummary(nil, " ") -} - -func TestInteractiveResolutionMerge(t *testing.T) { - // Test that mergeFieldLevel is called correctly in resolution - now := time.Now() - earlier := now.Add(-1 * time.Hour) - - local := &beads.Issue{ - ID: "test-1", - Title: "Local title", - Status: beads.StatusOpen, - Priority: 1, - Labels: []string{"bug"}, - UpdatedAt: now, - } - - remote := &beads.Issue{ - ID: "test-1", - Title: "Remote title", - Status: beads.StatusInProgress, - Priority: 2, - Labels: []string{"feature"}, - UpdatedAt: earlier, - } - - // mergeFieldLevel should pick local values (newer) for scalars - // and union for labels - merged, _ := mergeFieldLevel(nil, local, remote) - - if merged.Title != "Local title" { - t.Errorf("Expected title 'Local title', got %q", merged.Title) - } - if merged.Status != beads.StatusOpen { - t.Errorf("Expected status 'open', got %q", merged.Status) - } - if merged.Priority != 1 { - t.Errorf("Expected priority 1, got %d", merged.Priority) - } - // Labels should be merged (union) - if len(merged.Labels) != 2 { - t.Errorf("Expected 2 labels, got %d", len(merged.Labels)) - } - labelsStr := strings.Join(merged.Labels, ",") - if !strings.Contains(labelsStr, "bug") || !strings.Contains(labelsStr, "feature") { - t.Errorf("Expected labels to contain 'bug' and 'feature', got %v", merged.Labels) - } -} - -func TestInteractiveResolutionChoices(t *testing.T) { - // Test InteractiveResolution struct values - tests := []struct { - name string - choice string - issue *beads.Issue - }{ - {"local", "local", &beads.Issue{ID: "test"}}, - {"remote", "remote", &beads.Issue{ID: "test"}}, - {"merged", "merged", &beads.Issue{ID: "test"}}, - {"skip", "skip", nil}, - {"quit", "quit", nil}, - {"accept-all", "accept-all", nil}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - res := InteractiveResolution{Choice: tt.choice, Issue: tt.issue} - if res.Choice != tt.choice { - t.Errorf("Expected choice %q, got %q", tt.choice, res.Choice) - } - if tt.issue == nil && res.Issue != nil { - t.Errorf("Expected nil issue, got %v", res.Issue) - } - if tt.issue != nil && res.Issue == nil { - t.Errorf("Expected non-nil issue, got nil") - } - }) - } -} diff --git a/cmd/bd/sync_merge.go b/cmd/bd/sync_merge.go deleted file mode 100644 index d03093fbc..000000000 --- a/cmd/bd/sync_merge.go +++ /dev/null @@ -1,772 +0,0 @@ -package main - -import ( - "bufio" - "encoding/json" - "fmt" - "os" - "path/filepath" - "sort" - "time" - - "github.com/steveyegge/beads/internal/beads" - "github.com/steveyegge/beads/internal/config" -) - -// MergeResult contains the outcome of a 3-way merge -type MergeResult struct { - Merged []*beads.Issue // Final merged state - Conflicts int // Number of true conflicts resolved - Strategy map[string]string // Per-issue: "local", "remote", "merged", "same" - ManualConflicts []ManualConflict // Fields requiring manual resolution -} - -// ManualConflict represents a field conflict that requires manual user resolution. -// When a field's strategy is "manual", the conflict is flagged here instead of -// being auto-resolved. -type ManualConflict struct { - IssueID string // Issue ID with conflict - Field string // Field name (e.g., "estimated_minutes") - LocalValue interface{} // Local (ours) value - RemoteValue interface{} // Remote (theirs) value - LocalTime time.Time // When local value was set - RemoteTime time.Time // When remote value was set -} - -// MergeStrategy constants for describing how each issue was merged -const ( - StrategyLocal = "local" // Only local changed - StrategyRemote = "remote" // Only remote changed - StrategyMerged = "merged" // True conflict, LWW applied - StrategySame = "same" // Both made identical change (or no change) -) - -// mergeFieldLevel performs field-by-field merge for true conflicts. -// Returns a new issue with: -// - Scalar fields: from the newer issue (LWW by updated_at, remote wins on tie) -// - Labels: union of both -// - Dependencies: union of both (by DependsOnID+Type) -// - Comments: append from both (deduplicated by ID or content) -// - compaction_level: max strategy (highest value wins) -// - estimated_minutes: manual strategy if configured (flags for user resolution) -// -// Also returns any manual conflicts that require user resolution. -func mergeFieldLevel(_base, local, remote *beads.Issue) (*beads.Issue, []ManualConflict) { - var manualConflicts []ManualConflict - - // Determine which is newer for LWW scalars - localNewer := local.UpdatedAt.After(remote.UpdatedAt) - - // Clock skew detection: warn if timestamps differ by more than 24 hours - timeDiff := local.UpdatedAt.Sub(remote.UpdatedAt) - if timeDiff < 0 { - timeDiff = -timeDiff - } - if timeDiff > 24*time.Hour { - fmt.Fprintf(os.Stderr, "Warning: Issue %s has %v timestamp difference (possible clock skew)\n", - local.ID, timeDiff.Round(time.Hour)) - } - - // Start with a copy of the newer issue for scalar fields - var merged beads.Issue - if localNewer { - merged = *local - } else { - merged = *remote - } - - // Get per-field strategies from config - fieldStrategies := config.GetFieldStrategies() - - // Handle compaction_level with configurable strategy (default: max) - compactionStrategy := fieldStrategies["compaction_level"] - if compactionStrategy == "" { - compactionStrategy = config.FieldStrategyMax // Default for compaction_level - } - switch compactionStrategy { - case config.FieldStrategyMax: - merged.CompactionLevel = maxInt(local.CompactionLevel, remote.CompactionLevel) - case config.FieldStrategyNewest: - // Already handled by default LWW merge above - case config.FieldStrategyManual: - if local.CompactionLevel != remote.CompactionLevel { - manualConflicts = append(manualConflicts, ManualConflict{ - IssueID: local.ID, - Field: "compaction_level", - LocalValue: local.CompactionLevel, - RemoteValue: remote.CompactionLevel, - LocalTime: local.UpdatedAt, - RemoteTime: remote.UpdatedAt, - }) - // Keep local value as tentative (can be overridden by resolve command) - merged.CompactionLevel = local.CompactionLevel - } - } - - // Handle estimated_minutes with configurable strategy (default: manual per spec) - estimatedStrategy := fieldStrategies["estimated_minutes"] - if estimatedStrategy == "" { - estimatedStrategy = config.FieldStrategyManual // Default for estimated_minutes (human judgment needed) - } - switch estimatedStrategy { - case config.FieldStrategyMax: - merged.EstimatedMinutes = maxIntPtr(local.EstimatedMinutes, remote.EstimatedMinutes) - case config.FieldStrategyNewest: - // Already handled by default LWW merge above - case config.FieldStrategyManual: - if !intPtrEqual(local.EstimatedMinutes, remote.EstimatedMinutes) { - manualConflicts = append(manualConflicts, ManualConflict{ - IssueID: local.ID, - Field: "estimated_minutes", - LocalValue: derefIntPtr(local.EstimatedMinutes), - RemoteValue: derefIntPtr(remote.EstimatedMinutes), - LocalTime: local.UpdatedAt, - RemoteTime: remote.UpdatedAt, - }) - // Keep local value as tentative - merged.EstimatedMinutes = local.EstimatedMinutes - } - } - - // Union merge: Labels (always union unless configured otherwise) - labelsStrategy := fieldStrategies["labels"] - if labelsStrategy == "" || labelsStrategy == config.FieldStrategyUnion { - merged.Labels = mergeLabels(local.Labels, remote.Labels) - } else if labelsStrategy == config.FieldStrategyNewest { - // Use LWW for labels (already set from initial merge) - } - - // Union merge: Dependencies (by DependsOnID+Type key) - merged.Dependencies = mergeDependencies(local.Dependencies, remote.Dependencies) - - // Append merge: Comments (deduplicated) - merged.Comments = mergeComments(local.Comments, remote.Comments) - - return &merged, manualConflicts -} - -// maxInt returns the larger of two integers -func maxInt(a, b int) int { - if a > b { - return a - } - return b -} - -// maxIntPtr returns a pointer to the larger of two *int values -// Treats nil as 0 for comparison purposes -func maxIntPtr(a, b *int) *int { - aVal := 0 - bVal := 0 - if a != nil { - aVal = *a - } - if b != nil { - bVal = *b - } - if aVal >= bVal { - return a - } - return b -} - -// derefIntPtr safely dereferences an int pointer, returning nil representation for display -func derefIntPtr(p *int) interface{} { - if p == nil { - return nil - } - return *p -} - -// displayManualConflicts prints manual conflicts that need user resolution. -// These are fields where the configured strategy is "manual" and values differ. -func displayManualConflicts(conflicts []ManualConflict) { - fmt.Fprintf(os.Stderr, "\n⚠ %d field conflict(s) require manual resolution:\n", len(conflicts)) - - for _, c := range conflicts { - fmt.Fprintf(os.Stderr, "\n %s.%s:\n", c.IssueID, c.Field) - fmt.Fprintf(os.Stderr, " Local: %v (set %s)\n", formatConflictValue(c.LocalValue), c.LocalTime.Format("2006-01-02")) - fmt.Fprintf(os.Stderr, " Remote: %v (set %s)\n", formatConflictValue(c.RemoteValue), c.RemoteTime.Format("2006-01-02")) - } - - fmt.Fprintf(os.Stderr, "\n To resolve, use one of:\n") - fmt.Fprintf(os.Stderr, " bd sync --ours # Keep all local values\n") - fmt.Fprintf(os.Stderr, " bd sync --theirs # Keep all remote values\n") - fmt.Fprintf(os.Stderr, " bd resolve # Set specific value\n\n") -} - -// formatConflictValue formats a conflict value for display -func formatConflictValue(v interface{}) string { - if v == nil { - return "(not set)" - } - return fmt.Sprintf("%v", v) -} - -// mergeLabels performs set union on labels -func mergeLabels(local, remote []string) []string { - seen := make(map[string]bool) - var result []string - - // Add all local labels - for _, label := range local { - if !seen[label] { - seen[label] = true - result = append(result, label) - } - } - - // Add remote labels not in local - for _, label := range remote { - if !seen[label] { - seen[label] = true - result = append(result, label) - } - } - - // Sort for deterministic output - sort.Strings(result) - return result -} - -// dependencyKey creates a unique key for deduplication -// Uses DependsOnID + Type as the identity (same target+type = same dependency) -func dependencyKey(d *beads.Dependency) string { - if d == nil { - return "" - } - return d.DependsOnID + ":" + string(d.Type) -} - -// mergeDependencies performs set union on dependencies -func mergeDependencies(local, remote []*beads.Dependency) []*beads.Dependency { - seen := make(map[string]*beads.Dependency) - - // Add all local dependencies - for _, dep := range local { - if dep == nil { - continue - } - key := dependencyKey(dep) - seen[key] = dep - } - - // Add remote dependencies not in local (or with newer timestamp) - for _, dep := range remote { - if dep == nil { - continue - } - key := dependencyKey(dep) - if existing, ok := seen[key]; ok { - // Keep the one with newer CreatedAt - if dep.CreatedAt.After(existing.CreatedAt) { - seen[key] = dep - } - } else { - seen[key] = dep - } - } - - // Collect and sort by key for deterministic output - keys := make([]string, 0, len(seen)) - for k := range seen { - keys = append(keys, k) - } - sort.Strings(keys) - - result := make([]*beads.Dependency, 0, len(keys)) - for _, k := range keys { - result = append(result, seen[k]) - } - - return result -} - -// commentKey creates a unique key for deduplication -// Uses ID if present, otherwise content hash -func commentKey(c *beads.Comment) string { - if c == nil { - return "" - } - if c.ID != 0 { - return fmt.Sprintf("id:%d", c.ID) - } - // Fallback to content-based key for comments without ID - return fmt.Sprintf("content:%s:%s", c.Author, c.Text) -} - -// mergeComments performs append-merge on comments with deduplication -func mergeComments(local, remote []*beads.Comment) []*beads.Comment { - seen := make(map[string]*beads.Comment) - - // Add all local comments - for _, c := range local { - if c == nil { - continue - } - key := commentKey(c) - seen[key] = c - } - - // Add remote comments not in local - for _, c := range remote { - if c == nil { - continue - } - key := commentKey(c) - if _, ok := seen[key]; !ok { - seen[key] = c - } - } - - // Collect all comments - result := make([]*beads.Comment, 0, len(seen)) - for _, c := range seen { - result = append(result, c) - } - - // Sort by CreatedAt for chronological order - sort.Slice(result, func(i, j int) bool { - return result[i].CreatedAt.Before(result[j].CreatedAt) - }) - - return result -} - -// MergeIssues performs 3-way merge: base x local x remote -> merged -// -// Algorithm: -// 1. Build lookup maps for base, local, and remote by issue ID -// 2. Collect all unique issue IDs across all three sets -// 3. For each ID, apply MergeIssue to determine final state -// 4. Return merged result with per-issue strategy annotations -func MergeIssues(base, local, remote []*beads.Issue) *MergeResult { - // Build lookup maps by issue ID - baseMap := buildIssueMap(base) - localMap := buildIssueMap(local) - remoteMap := buildIssueMap(remote) - - // Collect all unique issue IDs - allIDs := collectUniqueIDs(baseMap, localMap, remoteMap) - - result := &MergeResult{ - Merged: make([]*beads.Issue, 0, len(allIDs)), - Strategy: make(map[string]string), - ManualConflicts: make([]ManualConflict, 0), - } - - for _, id := range allIDs { - baseIssue := baseMap[id] - localIssue := localMap[id] - remoteIssue := remoteMap[id] - - merged, strategy, manualConflicts := MergeIssue(baseIssue, localIssue, remoteIssue) - - // Always record strategy (even for deletions, for logging/debugging) - result.Strategy[id] = strategy - - // Collect manual conflicts for fields that need user resolution - if len(manualConflicts) > 0 { - result.ManualConflicts = append(result.ManualConflicts, manualConflicts...) - } - - if merged != nil { - result.Merged = append(result.Merged, merged) - if strategy == StrategyMerged { - result.Conflicts++ - } - } - // If merged is nil, the issue was deleted (present in base but not in local/remote) - } - - return result -} - -// MergeIssue merges a single issue using 3-way algorithm -// -// Cases: -// - base=nil: First sync (no common ancestor) -// - local=nil, remote=nil: impossible (would not be in allIDs) -// - local=nil: return remote (new from remote) -// - remote=nil: return local (new from local) -// - both exist: LWW by updated_at (both added independently) -// -// - base!=nil: Standard 3-way merge -// - base=local=remote: no changes (same) -// - base=local, remote differs: only remote changed (remote) -// - base=remote, local differs: only local changed (local) -// - local=remote (but differs from base): both made identical change (same) -// - all three differ: true conflict, LWW by updated_at (merged) -// -// - Deletion handling: -// - local=nil (deleted locally): if remote unchanged from base, delete; else keep remote -// - remote=nil (deleted remotely): if local unchanged from base, delete; else keep local -func MergeIssue(base, local, remote *beads.Issue) (*beads.Issue, string, []ManualConflict) { - // Case: no base state (first sync) - if base == nil { - if local == nil && remote == nil { - // Should not happen (would not be in allIDs) - return nil, StrategySame, nil - } - if local == nil { - return remote, StrategyRemote, nil - } - if remote == nil { - return local, StrategyLocal, nil - } - // Both exist with no base: treat as conflict, use field-level merge - // This allows labels/comments to be union-merged even in first sync - merged, manualConflicts := mergeFieldLevel(nil, local, remote) - return merged, StrategyMerged, manualConflicts - } - - // Case: local deleted - if local == nil { - // If remote unchanged from base, honor the local deletion - if issueEqual(base, remote) { - return nil, StrategyLocal, nil - } - // Remote changed after local deleted: keep remote (remote wins conflict) - return remote, StrategyMerged, nil - } - - // Case: remote deleted - if remote == nil { - // If local unchanged from base, honor the remote deletion - if issueEqual(base, local) { - return nil, StrategyRemote, nil - } - // Local changed after remote deleted: keep local (local wins conflict) - return local, StrategyMerged, nil - } - - // Standard 3-way cases (all three exist) - if issueEqual(base, local) && issueEqual(base, remote) { - // No changes anywhere - return local, StrategySame, nil - } - - if issueEqual(base, local) { - // Only remote changed - return remote, StrategyRemote, nil - } - - if issueEqual(base, remote) { - // Only local changed - return local, StrategyLocal, nil - } - - if issueEqual(local, remote) { - // Both made identical change - return local, StrategySame, nil - } - - // True conflict: use field-level merge - // - Scalar fields use LWW (remote wins on tie) - // - Labels use union (no data loss) - // - Dependencies use union (no data loss) - // - Comments use append (deduplicated) - // - compaction_level uses max (or configured strategy) - // - estimated_minutes uses configured strategy (may flag for manual resolution) - merged, manualConflicts := mergeFieldLevel(base, local, remote) - return merged, StrategyMerged, manualConflicts -} - -// issueEqual compares two issues for equality (content-level, not pointer) -// Compares all merge-relevant fields: content, status, workflow, assignment -func issueEqual(a, b *beads.Issue) bool { - if a == nil || b == nil { - return a == nil && b == nil - } - - // Core identification - if a.ID != b.ID { - return false - } - - // Issue content - if a.Title != b.Title || - a.Description != b.Description || - a.Design != b.Design || - a.AcceptanceCriteria != b.AcceptanceCriteria || - a.Notes != b.Notes { - return false - } - - // Status & workflow - if a.Status != b.Status || - a.Priority != b.Priority || - a.IssueType != b.IssueType { - return false - } - - // Assignment - if a.Assignee != b.Assignee { - return false - } - if !intPtrEqual(a.EstimatedMinutes, b.EstimatedMinutes) { - return false - } - - // Timestamps (updated_at is crucial for LWW) - if !a.UpdatedAt.Equal(b.UpdatedAt) { - return false - } - - // Closed state - if !timePtrEqual(a.ClosedAt, b.ClosedAt) || - a.CloseReason != b.CloseReason { - return false - } - - // Time-based scheduling - if !timePtrEqual(a.DueAt, b.DueAt) || - !timePtrEqual(a.DeferUntil, b.DeferUntil) { - return false - } - - // External reference - if !stringPtrEqual(a.ExternalRef, b.ExternalRef) { - return false - } - - // Labels (order-independent comparison) - if !stringSliceEqual(a.Labels, b.Labels) { - return false - } - - // Dependencies (order-independent comparison) - if !dependenciesEqual(a.Dependencies, b.Dependencies) { - return false - } - - // Comments (order-independent comparison) - if !commentsEqual(a.Comments, b.Comments) { - return false - } - - return true -} - -// buildIssueMap creates a lookup map from issue ID to issue pointer -func buildIssueMap(issues []*beads.Issue) map[string]*beads.Issue { - m := make(map[string]*beads.Issue, len(issues)) - for _, issue := range issues { - if issue != nil { - m[issue.ID] = issue - } - } - return m -} - -// collectUniqueIDs gathers all unique issue IDs from the three maps -// Returns sorted for deterministic output -func collectUniqueIDs(base, local, remote map[string]*beads.Issue) []string { - seen := make(map[string]bool) - for id := range base { - seen[id] = true - } - for id := range local { - seen[id] = true - } - for id := range remote { - seen[id] = true - } - - ids := make([]string, 0, len(seen)) - for id := range seen { - ids = append(ids, id) - } - sort.Strings(ids) - return ids -} - -// Helper functions for pointer comparison - -func intPtrEqual(a, b *int) bool { - if a == nil && b == nil { - return true - } - if a == nil || b == nil { - return false - } - return *a == *b -} - -func stringPtrEqual(a, b *string) bool { - if a == nil && b == nil { - return true - } - if a == nil || b == nil { - return false - } - return *a == *b -} - -func timePtrEqual(a, b *time.Time) bool { - if a == nil && b == nil { - return true - } - if a == nil || b == nil { - return false - } - return a.Equal(*b) -} - -func stringSliceEqual(a, b []string) bool { - if len(a) != len(b) { - return false - } - // Sort copies for order-independent comparison - aCopy := make([]string, len(a)) - bCopy := make([]string, len(b)) - copy(aCopy, a) - copy(bCopy, b) - sort.Strings(aCopy) - sort.Strings(bCopy) - for i := range aCopy { - if aCopy[i] != bCopy[i] { - return false - } - } - return true -} - -// dependenciesEqual compares two dependency slices for equality (order-independent). -// Compares by (depends_on_id, type) pairs which form the logical identity of a dependency. -func dependenciesEqual(a, b []*beads.Dependency) bool { - if len(a) != len(b) { - return false - } - if len(a) == 0 { - return true - } - // Build key sets for order-independent comparison - aKeys := make([]string, len(a)) - for i, d := range a { - aKeys[i] = fmt.Sprintf("%s:%s", d.DependsOnID, d.Type) - } - bKeys := make([]string, len(b)) - for i, d := range b { - bKeys[i] = fmt.Sprintf("%s:%s", d.DependsOnID, d.Type) - } - sort.Strings(aKeys) - sort.Strings(bKeys) - for i := range aKeys { - if aKeys[i] != bKeys[i] { - return false - } - } - return true -} - -// commentsEqual compares two comment slices for equality (order-independent). -// Compares by (author, text, created_at) which identifies a comment's content. -func commentsEqual(a, b []*beads.Comment) bool { - if len(a) != len(b) { - return false - } - if len(a) == 0 { - return true - } - // Build key sets for order-independent comparison - aKeys := make([]string, len(a)) - for i, c := range a { - aKeys[i] = fmt.Sprintf("%s:%s:%d", c.Author, c.Text, c.CreatedAt.UnixNano()) - } - bKeys := make([]string, len(b)) - for i, c := range b { - bKeys[i] = fmt.Sprintf("%s:%s:%d", c.Author, c.Text, c.CreatedAt.UnixNano()) - } - sort.Strings(aKeys) - sort.Strings(bKeys) - for i := range aKeys { - if aKeys[i] != bKeys[i] { - return false - } - } - return true -} - -// Base state storage functions for sync_base.jsonl - -const syncBaseFileName = "sync_base.jsonl" - -// loadBaseState loads the last-synced state from .beads/sync_base.jsonl -// Returns empty slice if file doesn't exist (first sync scenario) -func loadBaseState(beadsDir string) ([]*beads.Issue, error) { - baseStatePath := filepath.Join(beadsDir, syncBaseFileName) - - // Check if file exists - if _, err := os.Stat(baseStatePath); os.IsNotExist(err) { - // First sync: no base state - return nil, nil - } - - // Read and parse JSONL file - file, err := os.Open(baseStatePath) - if err != nil { - return nil, err - } - defer file.Close() - - var issues []*beads.Issue - scanner := bufio.NewScanner(file) - // Increase buffer for large issues - buf := make([]byte, 0, 64*1024) - scanner.Buffer(buf, 1024*1024) - - lineNum := 0 - for scanner.Scan() { - lineNum++ - line := scanner.Text() - if line == "" { - continue - } - - var issue beads.Issue - if err := json.Unmarshal([]byte(line), &issue); err != nil { - fmt.Fprintf(os.Stderr, "Warning: Skipping malformed line %d in sync_base.jsonl: %v\n", lineNum, err) - continue - } - issues = append(issues, &issue) - } - - if err := scanner.Err(); err != nil { - return nil, err - } - - return issues, nil -} - -// saveBaseState writes the merged state to .beads/sync_base.jsonl -// This becomes the base for the next 3-way merge -func saveBaseState(beadsDir string, issues []*beads.Issue) error { - baseStatePath := filepath.Join(beadsDir, syncBaseFileName) - - // Write to temp file first for atomicity - tempPath := baseStatePath + ".tmp" - file, err := os.Create(tempPath) - if err != nil { - return err - } - - encoder := json.NewEncoder(file) - encoder.SetEscapeHTML(false) - - for _, issue := range issues { - if err := encoder.Encode(issue); err != nil { - _ = file.Close() // Best-effort cleanup - _ = os.Remove(tempPath) - return err - } - } - - if err := file.Close(); err != nil { - _ = os.Remove(tempPath) // Best-effort cleanup - return err - } - - // Atomic rename - return os.Rename(tempPath, baseStatePath) -} diff --git a/cmd/bd/sync_merge_test.go b/cmd/bd/sync_merge_test.go deleted file mode 100644 index 99626c7bb..000000000 --- a/cmd/bd/sync_merge_test.go +++ /dev/null @@ -1,1663 +0,0 @@ -//go:build cgo - -package main - -import ( - "bytes" - "context" - "os" - "path/filepath" - "strings" - "testing" - "time" - - "github.com/steveyegge/beads/internal/storage/dolt" - "github.com/steveyegge/beads/internal/types" -) - -// setupTestStore creates a test storage with issue_prefix configured -func setupTestStore(t *testing.T, dbPath string) *dolt.DoltStore { - t.Helper() - - store, err := dolt.New(context.Background(), &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("Failed to create store: %v", err) - } - - ctx := context.Background() - if err := store.SetConfig(ctx, "issue_prefix", "bd"); err != nil { - store.Close() - t.Fatalf("Failed to set issue_prefix: %v", err) - } - - return store -} - -// TestDBNeedsExport_InSync verifies dbNeedsExport returns false when DB and JSONL are in sync -func TestDBNeedsExport_InSync(t *testing.T) { - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "beads.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - store := setupTestStore(t, dbPath) - defer store.Close() - - ctx := context.Background() - - // Create an issue in DB - issue := &types.Issue{ - Title: "Test Issue", - Status: types.StatusOpen, - Priority: 1, - IssueType: types.TypeBug, - } - err := store.CreateIssue(ctx, issue, "test-user") - if err != nil { - t.Fatalf("Failed to create issue: %v", err) - } - - // Export to JSONL - if err := exportToJSONLWithStore(ctx, store, jsonlPath); err != nil { - t.Fatalf("Failed to export: %v", err) - } - - // Wait a moment to ensure DB mtime isn't newer - time.Sleep(10 * time.Millisecond) - - // Touch JSONL to make it newer than DB - now := time.Now() - if err := os.Chtimes(jsonlPath, now, now); err != nil { - t.Fatalf("Failed to touch JSONL: %v", err) - } - - // DB and JSONL should be in sync - needsExport, err := dbNeedsExport(ctx, store, jsonlPath) - if err != nil { - t.Fatalf("dbNeedsExport failed: %v", err) - } - - if needsExport { - t.Errorf("Expected needsExport=false (DB and JSONL in sync), got true") - } -} - -// TestDBNeedsExport_DBNewer verifies dbNeedsExport returns true when DB is modified -func TestDBNeedsExport_DBNewer(t *testing.T) { - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "beads.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - store := setupTestStore(t, dbPath) - defer store.Close() - - ctx := context.Background() - - // Create and export issue - issue1 := &types.Issue{ - Title: "Test Issue", - Status: types.StatusOpen, - Priority: 1, - IssueType: types.TypeBug, - } - err := store.CreateIssue(ctx, issue1, "test-user") - if err != nil { - t.Fatalf("Failed to create issue: %v", err) - } - - if err := exportToJSONLWithStore(ctx, store, jsonlPath); err != nil { - t.Fatalf("Failed to export: %v", err) - } - - // Wait and modify DB - time.Sleep(10 * time.Millisecond) - issue2 := &types.Issue{ - Title: "Another Issue", - Status: types.StatusOpen, - Priority: 2, - IssueType: types.TypeTask, - } - err = store.CreateIssue(ctx, issue2, "test-user") - if err != nil { - t.Fatalf("Failed to create second issue: %v", err) - } - - // DB is newer, should need export - needsExport, err := dbNeedsExport(ctx, store, jsonlPath) - if err != nil { - t.Fatalf("dbNeedsExport failed: %v", err) - } - - if !needsExport { - t.Errorf("Expected needsExport=true (DB modified), got false") - } -} - -// TestDBNeedsExport_CountMismatch verifies dbNeedsExport returns true when counts differ -func TestDBNeedsExport_CountMismatch(t *testing.T) { - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "beads.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - store := setupTestStore(t, dbPath) - defer store.Close() - - ctx := context.Background() - - // Create and export issue - issue1 := &types.Issue{ - Title: "Test Issue", - Status: types.StatusOpen, - Priority: 1, - IssueType: types.TypeBug, - } - err := store.CreateIssue(ctx, issue1, "test-user") - if err != nil { - t.Fatalf("Failed to create issue: %v", err) - } - - if err := exportToJSONLWithStore(ctx, store, jsonlPath); err != nil { - t.Fatalf("Failed to export: %v", err) - } - - // Add another issue to DB but don't export - issue2 := &types.Issue{ - Title: "Another Issue", - Status: types.StatusOpen, - Priority: 2, - IssueType: types.TypeTask, - } - err = store.CreateIssue(ctx, issue2, "test-user") - if err != nil { - t.Fatalf("Failed to create second issue: %v", err) - } - - // Make JSONL appear newer (but counts differ) - time.Sleep(10 * time.Millisecond) - now := time.Now().Add(1 * time.Hour) // Way in the future - if err := os.Chtimes(jsonlPath, now, now); err != nil { - t.Fatalf("Failed to touch JSONL: %v", err) - } - - // Counts mismatch, should need export - needsExport, err := dbNeedsExport(ctx, store, jsonlPath) - if err != nil { - t.Fatalf("dbNeedsExport failed: %v", err) - } - - if !needsExport { - t.Errorf("Expected needsExport=true (count mismatch), got false") - } -} - -// TestDBNeedsExport_NoJSONL verifies dbNeedsExport returns true when JSONL doesn't exist -func TestDBNeedsExport_NoJSONL(t *testing.T) { - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "beads.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - store := setupTestStore(t, dbPath) - defer store.Close() - - ctx := context.Background() - - // Create issue but don't export - issue := &types.Issue{ - Title: "Test Issue", - Status: types.StatusOpen, - Priority: 1, - IssueType: types.TypeBug, - } - err := store.CreateIssue(ctx, issue, "test-user") - if err != nil { - t.Fatalf("Failed to create issue: %v", err) - } - - // JSONL doesn't exist, should need export - needsExport, err := dbNeedsExport(ctx, store, jsonlPath) - if err != nil { - t.Fatalf("dbNeedsExport failed: %v", err) - } - - if !needsExport { - t.Fatalf("Expected needsExport=true (JSONL missing), got false") - } -} - -// ============================================================================= -// 3-Way Merge Tests (Phase 2) -// ============================================================================= - -// makeTestIssue creates a test issue with specified fields -func makeTestIssue(id, title string, status types.Status, priority int, updatedAt time.Time) *types.Issue { - return &types.Issue{ - ID: id, - Title: title, - Status: status, - Priority: priority, - IssueType: types.TypeTask, - UpdatedAt: updatedAt, - CreatedAt: updatedAt.Add(-time.Hour), // Created 1 hour before update - } -} - -// TestMergeIssue_NoBase_LocalOnly tests first sync with only local issue -func TestMergeIssue_NoBase_LocalOnly(t *testing.T) { - local := makeTestIssue("bd-1234", "Local Issue", types.StatusOpen, 1, time.Now()) - - merged, strategy, _ := MergeIssue(nil, local, nil) - - if strategy != StrategyLocal { - t.Errorf("Expected strategy=%s, got %s", StrategyLocal, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - if merged.ID != "bd-1234" { - t.Errorf("Expected ID=bd-1234, got %s", merged.ID) - } -} - -// TestMergeIssue_NoBase_RemoteOnly tests first sync with only remote issue -func TestMergeIssue_NoBase_RemoteOnly(t *testing.T) { - remote := makeTestIssue("bd-5678", "Remote Issue", types.StatusOpen, 2, time.Now()) - - merged, strategy, _ := MergeIssue(nil, nil, remote) - - if strategy != StrategyRemote { - t.Errorf("Expected strategy=%s, got %s", StrategyRemote, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - if merged.ID != "bd-5678" { - t.Errorf("Expected ID=bd-5678, got %s", merged.ID) - } -} - -// TestMergeIssue_NoBase_BothExist_LocalNewer tests first sync where both have same issue, local is newer -func TestMergeIssue_NoBase_BothExist_LocalNewer(t *testing.T) { - now := time.Now() - local := makeTestIssue("bd-1234", "Local Title", types.StatusOpen, 1, now.Add(time.Hour)) - remote := makeTestIssue("bd-1234", "Remote Title", types.StatusOpen, 2, now) - - merged, strategy, _ := MergeIssue(nil, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - if merged.Title != "Local Title" { - t.Errorf("Expected local title (newer), got %s", merged.Title) - } -} - -// TestMergeIssue_NoBase_BothExist_RemoteNewer tests first sync where both have same issue, remote is newer -func TestMergeIssue_NoBase_BothExist_RemoteNewer(t *testing.T) { - now := time.Now() - local := makeTestIssue("bd-1234", "Local Title", types.StatusOpen, 1, now) - remote := makeTestIssue("bd-1234", "Remote Title", types.StatusOpen, 2, now.Add(time.Hour)) - - merged, strategy, _ := MergeIssue(nil, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - if merged.Title != "Remote Title" { - t.Errorf("Expected remote title (newer), got %s", merged.Title) - } -} - -// TestMergeIssue_NoBase_BothExist_SameTime tests first sync where both have same timestamp (remote wins) -func TestMergeIssue_NoBase_BothExist_SameTime(t *testing.T) { - now := time.Now() - local := makeTestIssue("bd-1234", "Local Title", types.StatusOpen, 1, now) - remote := makeTestIssue("bd-1234", "Remote Title", types.StatusOpen, 2, now) - - merged, strategy, _ := MergeIssue(nil, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - // Remote wins on tie (per design.md Decision 3) - if merged.Title != "Remote Title" { - t.Errorf("Expected remote title (tie goes to remote), got %s", merged.Title) - } -} - -// TestMergeIssue_NoChanges tests 3-way merge with no changes anywhere -func TestMergeIssue_NoChanges(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Same Title", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Same Title", types.StatusOpen, 1, now) - remote := makeTestIssue("bd-1234", "Same Title", types.StatusOpen, 1, now) - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategySame { - t.Errorf("Expected strategy=%s, got %s", StrategySame, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } -} - -// TestMergeIssue_OnlyLocalChanged tests 3-way merge where only local changed -func TestMergeIssue_OnlyLocalChanged(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Original Title", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Updated Title", types.StatusOpen, 1, now.Add(time.Hour)) - remote := makeTestIssue("bd-1234", "Original Title", types.StatusOpen, 1, now) - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategyLocal { - t.Errorf("Expected strategy=%s, got %s", StrategyLocal, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - if merged.Title != "Updated Title" { - t.Errorf("Expected updated title, got %s", merged.Title) - } -} - -// TestMergeIssue_OnlyRemoteChanged tests 3-way merge where only remote changed -func TestMergeIssue_OnlyRemoteChanged(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Original Title", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Original Title", types.StatusOpen, 1, now) - remote := makeTestIssue("bd-1234", "Updated Title", types.StatusOpen, 1, now.Add(time.Hour)) - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategyRemote { - t.Errorf("Expected strategy=%s, got %s", StrategyRemote, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - if merged.Title != "Updated Title" { - t.Errorf("Expected updated title, got %s", merged.Title) - } -} - -// TestMergeIssue_BothMadeSameChange tests 3-way merge where both made identical change -func TestMergeIssue_BothMadeSameChange(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Original Title", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Same Update", types.StatusClosed, 2, now.Add(time.Hour)) - remote := makeTestIssue("bd-1234", "Same Update", types.StatusClosed, 2, now.Add(time.Hour)) - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategySame { - t.Errorf("Expected strategy=%s, got %s", StrategySame, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - if merged.Title != "Same Update" { - t.Errorf("Expected 'Same Update', got %s", merged.Title) - } -} - -// TestMergeIssue_TrueConflict_LocalNewer tests true conflict where local is newer -func TestMergeIssue_TrueConflict_LocalNewer(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Original", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Local Update", types.StatusInProgress, 1, now.Add(2*time.Hour)) - remote := makeTestIssue("bd-1234", "Remote Update", types.StatusClosed, 2, now.Add(time.Hour)) - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - // Local is newer, should win - if merged.Title != "Local Update" { - t.Errorf("Expected local title (newer), got %s", merged.Title) - } - if merged.Status != types.StatusInProgress { - t.Errorf("Expected local status, got %s", merged.Status) - } -} - -// TestMergeIssue_TrueConflict_RemoteNewer tests true conflict where remote is newer -func TestMergeIssue_TrueConflict_RemoteNewer(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Original", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Local Update", types.StatusInProgress, 1, now.Add(time.Hour)) - remote := makeTestIssue("bd-1234", "Remote Update", types.StatusClosed, 2, now.Add(2*time.Hour)) - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - // Remote is newer, should win - if merged.Title != "Remote Update" { - t.Errorf("Expected remote title (newer), got %s", merged.Title) - } - if merged.Status != types.StatusClosed { - t.Errorf("Expected remote status, got %s", merged.Status) - } -} - -// TestMergeIssue_LocalDeleted_RemoteUnchanged tests local deletion when remote unchanged -func TestMergeIssue_LocalDeleted_RemoteUnchanged(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "To Delete", types.StatusOpen, 1, now) - remote := makeTestIssue("bd-1234", "To Delete", types.StatusOpen, 1, now) - - merged, strategy, _ := MergeIssue(base, nil, remote) - - if strategy != StrategyLocal { - t.Errorf("Expected strategy=%s (honor local deletion), got %s", StrategyLocal, strategy) - } - if merged != nil { - t.Errorf("Expected nil (deleted), got issue %s", merged.ID) - } -} - -// TestMergeIssue_LocalDeleted_RemoteChanged tests local deletion but remote changed -func TestMergeIssue_LocalDeleted_RemoteChanged(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Original", types.StatusOpen, 1, now) - remote := makeTestIssue("bd-1234", "Remote Updated", types.StatusClosed, 2, now.Add(time.Hour)) - - merged, strategy, _ := MergeIssue(base, nil, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s (conflict: deleted vs updated), got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue (remote changed), got nil") - } - if merged.Title != "Remote Updated" { - t.Errorf("Expected remote title (changed wins over delete), got %s", merged.Title) - } -} - -// TestMergeIssue_RemoteDeleted_LocalUnchanged tests remote deletion when local unchanged -func TestMergeIssue_RemoteDeleted_LocalUnchanged(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "To Delete", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "To Delete", types.StatusOpen, 1, now) - - merged, strategy, _ := MergeIssue(base, local, nil) - - if strategy != StrategyRemote { - t.Errorf("Expected strategy=%s (honor remote deletion), got %s", StrategyRemote, strategy) - } - if merged != nil { - t.Errorf("Expected nil (deleted), got issue %s", merged.ID) - } -} - -// TestMergeIssue_RemoteDeleted_LocalChanged tests remote deletion but local changed -func TestMergeIssue_RemoteDeleted_LocalChanged(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Original", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Local Updated", types.StatusClosed, 2, now.Add(time.Hour)) - - merged, strategy, _ := MergeIssue(base, local, nil) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s (conflict: updated vs deleted), got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue (local changed), got nil") - } - if merged.Title != "Local Updated" { - t.Errorf("Expected local title (changed wins over delete), got %s", merged.Title) - } -} - -// TestMergeIssues_Empty tests merging empty sets -func TestMergeIssues_Empty(t *testing.T) { - result := MergeIssues(nil, nil, nil) - if len(result.Merged) != 0 { - t.Errorf("Expected 0 merged issues, got %d", len(result.Merged)) - } - if result.Conflicts != 0 { - t.Errorf("Expected 0 conflicts, got %d", result.Conflicts) - } -} - -// TestMergeIssues_MultipleIssues tests merging multiple issues with different scenarios -func TestMergeIssues_MultipleIssues(t *testing.T) { - now := time.Now() - - // Base state - base := []*types.Issue{ - makeTestIssue("bd-0001", "Unchanged", types.StatusOpen, 1, now), - makeTestIssue("bd-0002", "Will change locally", types.StatusOpen, 1, now), - makeTestIssue("bd-0003", "Will change remotely", types.StatusOpen, 1, now), - makeTestIssue("bd-0004", "To delete locally", types.StatusOpen, 1, now), - } - - // Local state - local := []*types.Issue{ - makeTestIssue("bd-0001", "Unchanged", types.StatusOpen, 1, now), - makeTestIssue("bd-0002", "Changed locally", types.StatusInProgress, 1, now.Add(time.Hour)), - makeTestIssue("bd-0003", "Will change remotely", types.StatusOpen, 1, now), - // bd-0004 deleted locally - makeTestIssue("bd-0005", "New local issue", types.StatusOpen, 1, now), // New issue - } - - // Remote state - remote := []*types.Issue{ - makeTestIssue("bd-0001", "Unchanged", types.StatusOpen, 1, now), - makeTestIssue("bd-0002", "Will change locally", types.StatusOpen, 1, now), - makeTestIssue("bd-0003", "Changed remotely", types.StatusClosed, 2, now.Add(time.Hour)), - makeTestIssue("bd-0004", "To delete locally", types.StatusOpen, 1, now), // Unchanged from base - makeTestIssue("bd-0006", "New remote issue", types.StatusOpen, 1, now), // New issue - } - - result := MergeIssues(base, local, remote) - - // Should have 5 issues: - // - bd-0001: same - // - bd-0002: local changed - // - bd-0003: remote changed - // - bd-0004: deleted (not in merged) - // - bd-0005: new local - // - bd-0006: new remote - if len(result.Merged) != 5 { - t.Errorf("Expected 5 merged issues, got %d", len(result.Merged)) - } - - // Verify strategies - expectedStrategies := map[string]string{ - "bd-0001": StrategySame, - "bd-0002": StrategyLocal, - "bd-0003": StrategyRemote, - "bd-0004": StrategyLocal, // Deleted locally - "bd-0005": StrategyLocal, - "bd-0006": StrategyRemote, - } - - for id, expected := range expectedStrategies { - if got := result.Strategy[id]; got != expected { - t.Errorf("Issue %s: expected strategy=%s, got %s", id, expected, got) - } - } - - // Verify bd-0004 is not in merged (deleted) - for _, issue := range result.Merged { - if issue.ID == "bd-0004" { - t.Errorf("bd-0004 should be deleted, but found in merged") - } - } -} - -// TestBaseState_LoadSave tests loading and saving base state -func TestBaseState_LoadSave(t *testing.T) { - tmpDir := t.TempDir() - now := time.Now().Truncate(time.Second) // Truncate for JSON round-trip - - issues := []*types.Issue{ - { - ID: "bd-0001", - Title: "Test Issue 1", - Status: types.StatusOpen, - Priority: 1, - IssueType: types.TypeTask, - UpdatedAt: now, - CreatedAt: now.Add(-time.Hour), - }, - { - ID: "bd-0002", - Title: "Test Issue 2", - Status: types.StatusClosed, - Priority: 2, - IssueType: types.TypeBug, - UpdatedAt: now, - CreatedAt: now.Add(-time.Hour), - }, - } - - // Save base state - if err := saveBaseState(tmpDir, issues); err != nil { - t.Fatalf("saveBaseState failed: %v", err) - } - - // Verify file exists - baseStatePath := filepath.Join(tmpDir, syncBaseFileName) - if _, err := os.Stat(baseStatePath); os.IsNotExist(err) { - t.Fatalf("Base state file not created") - } - - // Load base state - loaded, err := loadBaseState(tmpDir) - if err != nil { - t.Fatalf("loadBaseState failed: %v", err) - } - - if len(loaded) != 2 { - t.Fatalf("Expected 2 issues, got %d", len(loaded)) - } - - // Verify issue content - if loaded[0].ID != "bd-0001" || loaded[0].Title != "Test Issue 1" { - t.Errorf("First issue mismatch: got ID=%s, Title=%s", loaded[0].ID, loaded[0].Title) - } - if loaded[1].ID != "bd-0002" || loaded[1].Title != "Test Issue 2" { - t.Errorf("Second issue mismatch: got ID=%s, Title=%s", loaded[1].ID, loaded[1].Title) - } -} - -// TestBaseState_LoadMissing tests loading when no base state exists -func TestBaseState_LoadMissing(t *testing.T) { - tmpDir := t.TempDir() - - loaded, err := loadBaseState(tmpDir) - if err != nil { - t.Fatalf("loadBaseState failed: %v", err) - } - - if loaded != nil { - t.Errorf("Expected nil for missing base state, got %d issues", len(loaded)) - } -} - -// TestBaseState_LoadMalformed tests loading sync_base.jsonl with malformed lines -func TestBaseState_LoadMalformed(t *testing.T) { - tmpDir := t.TempDir() - baseStatePath := filepath.Join(tmpDir, syncBaseFileName) - - // Create file with mix of valid and malformed lines - content := `{"id":"bd-0001","title":"Valid Issue","status":"open","priority":1,"issue_type":"task"} -not valid json at all -{"id":"bd-0002","title":"Another Valid","status":"closed","priority":2,"issue_type":"bug"} -{truncated json -{"id":"bd-0003","title":"Third Valid","status":"open","priority":3,"issue_type":"task"} -` - if err := os.WriteFile(baseStatePath, []byte(content), 0644); err != nil { - t.Fatalf("Failed to write test file: %v", err) - } - - // Capture stderr to verify warning is produced - oldStderr := os.Stderr - r, w, _ := os.Pipe() - os.Stderr = w - - loaded, err := loadBaseState(tmpDir) - - // Restore stderr and read captured output - w.Close() - os.Stderr = oldStderr - var stderrBuf bytes.Buffer - stderrBuf.ReadFrom(r) - stderrOutput := stderrBuf.String() - - if err != nil { - t.Fatalf("loadBaseState failed: %v", err) - } - - // Should have loaded 3 valid issues, skipping 2 malformed lines - if len(loaded) != 3 { - t.Errorf("Expected 3 valid issues, got %d", len(loaded)) - } - - // Verify correct issues loaded - expectedIDs := []string{"bd-0001", "bd-0002", "bd-0003"} - for i, expected := range expectedIDs { - if i >= len(loaded) { - t.Errorf("Missing issue at index %d", i) - continue - } - if loaded[i].ID != expected { - t.Errorf("Issue %d: expected ID=%s, got %s", i, expected, loaded[i].ID) - } - } - - // Verify warnings were produced for malformed lines (lines 2 and 4) - if !strings.Contains(stderrOutput, "line 2") { - t.Errorf("Expected warning for line 2, got: %s", stderrOutput) - } - if !strings.Contains(stderrOutput, "line 4") { - t.Errorf("Expected warning for line 4, got: %s", stderrOutput) - } -} - -// TestIssueEqual tests the issueEqual helper function -func TestIssueEqual(t *testing.T) { - now := time.Now() - - tests := []struct { - name string - a, b *types.Issue - expected bool - }{ - { - name: "both nil", - a: nil, - b: nil, - expected: true, - }, - { - name: "a nil", - a: nil, - b: makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now), - expected: false, - }, - { - name: "b nil", - a: makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now), - b: nil, - expected: false, - }, - { - name: "identical", - a: makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now), - b: makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now), - expected: true, - }, - { - name: "different ID", - a: makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now), - b: makeTestIssue("bd-5678", "Test", types.StatusOpen, 1, now), - expected: false, - }, - { - name: "different title", - a: makeTestIssue("bd-1234", "Test A", types.StatusOpen, 1, now), - b: makeTestIssue("bd-1234", "Test B", types.StatusOpen, 1, now), - expected: false, - }, - { - name: "different status", - a: makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now), - b: makeTestIssue("bd-1234", "Test", types.StatusClosed, 1, now), - expected: false, - }, - { - name: "different priority", - a: makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now), - b: makeTestIssue("bd-1234", "Test", types.StatusOpen, 2, now), - expected: false, - }, - { - name: "different updated_at", - a: makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now), - b: makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now.Add(time.Hour)), - expected: false, - }, - { - name: "different dependencies", - a: func() *types.Issue { - i := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now) - i.Dependencies = []*types.Dependency{{DependsOnID: "bd-5678", Type: types.DepBlocks}} - return i - }(), - b: makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now), - expected: false, - }, - { - name: "same dependencies different order", - a: func() *types.Issue { - i := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now) - i.Dependencies = []*types.Dependency{ - {DependsOnID: "bd-5678", Type: types.DepBlocks}, - {DependsOnID: "bd-9999", Type: types.DepBlocks}, - } - return i - }(), - b: func() *types.Issue { - i := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now) - i.Dependencies = []*types.Dependency{ - {DependsOnID: "bd-9999", Type: types.DepBlocks}, - {DependsOnID: "bd-5678", Type: types.DepBlocks}, - } - return i - }(), - expected: true, - }, - { - name: "different comments", - a: func() *types.Issue { - i := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now) - i.Comments = []*types.Comment{{Author: "alice", Text: "hello", CreatedAt: now}} - return i - }(), - b: makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now), - expected: false, - }, - { - name: "same comments", - a: func() *types.Issue { - i := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now) - i.Comments = []*types.Comment{{Author: "alice", Text: "hello", CreatedAt: now}} - return i - }(), - b: func() *types.Issue { - i := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now) - i.Comments = []*types.Comment{{Author: "alice", Text: "hello", CreatedAt: now}} - return i - }(), - expected: true, - }, - } - - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - result := issueEqual(tc.a, tc.b) - if result != tc.expected { - t.Errorf("issueEqual returned %v, expected %v", result, tc.expected) - } - }) - } -} - -// ============================================================================= -// Field-Level Merge Tests (Phase 3) -// ============================================================================= - -// makeTestIssueWithLabels creates a test issue with labels -func makeTestIssueWithLabels(id, title string, status types.Status, priority int, updatedAt time.Time, labels []string) *types.Issue { - issue := makeTestIssue(id, title, status, priority, updatedAt) - issue.Labels = labels - return issue -} - -// TestFieldMerge_LWW_LocalNewer tests field-level merge where local is newer -func TestFieldMerge_LWW_LocalNewer(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Original", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Local Update", types.StatusInProgress, 2, now.Add(2*time.Hour)) - remote := makeTestIssue("bd-1234", "Remote Update", types.StatusClosed, 3, now.Add(time.Hour)) - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - // Local is newer, should have local's scalar values - if merged.Title != "Local Update" { - t.Errorf("Expected title='Local Update' (local is newer), got %s", merged.Title) - } - if merged.Status != types.StatusInProgress { - t.Errorf("Expected status=in_progress (local is newer), got %s", merged.Status) - } - if merged.Priority != 2 { - t.Errorf("Expected priority=2 (local is newer), got %d", merged.Priority) - } -} - -// TestFieldMerge_LWW_RemoteNewer tests field-level merge where remote is newer -func TestFieldMerge_LWW_RemoteNewer(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Original", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Local Update", types.StatusInProgress, 2, now.Add(time.Hour)) - remote := makeTestIssue("bd-1234", "Remote Update", types.StatusClosed, 3, now.Add(2*time.Hour)) - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - // Remote is newer, should have remote's scalar values - if merged.Title != "Remote Update" { - t.Errorf("Expected title='Remote Update' (remote is newer), got %s", merged.Title) - } - if merged.Status != types.StatusClosed { - t.Errorf("Expected status=closed (remote is newer), got %s", merged.Status) - } - if merged.Priority != 3 { - t.Errorf("Expected priority=3 (remote is newer), got %d", merged.Priority) - } -} - -// TestFieldMerge_LWW_SameTimestamp tests field-level merge where timestamps are equal (remote wins) -func TestFieldMerge_LWW_SameTimestamp(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Original", types.StatusOpen, 1, now.Add(-time.Hour)) - local := makeTestIssue("bd-1234", "Local Update", types.StatusInProgress, 2, now) - remote := makeTestIssue("bd-1234", "Remote Update", types.StatusClosed, 3, now) - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - // Same timestamp: remote wins (per design.md Decision 3) - if merged.Title != "Remote Update" { - t.Errorf("Expected title='Remote Update' (remote wins on tie), got %s", merged.Title) - } - if merged.Status != types.StatusClosed { - t.Errorf("Expected status=closed (remote wins on tie), got %s", merged.Status) - } -} - -// TestLabelUnion_BothAdd tests label union when both local and remote add different labels -func TestLabelUnion_BothAdd(t *testing.T) { - now := time.Now() - base := makeTestIssueWithLabels("bd-1234", "Test", types.StatusOpen, 1, now, []string{"original"}) - local := makeTestIssueWithLabels("bd-1234", "Test Local", types.StatusOpen, 1, now.Add(time.Hour), []string{"original", "local-added"}) - remote := makeTestIssueWithLabels("bd-1234", "Test Remote", types.StatusOpen, 1, now.Add(2*time.Hour), []string{"original", "remote-added"}) - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - - // Labels should be union of both - expectedLabels := []string{"local-added", "original", "remote-added"} - if len(merged.Labels) != len(expectedLabels) { - t.Errorf("Expected %d labels, got %d: %v", len(expectedLabels), len(merged.Labels), merged.Labels) - } - for _, expected := range expectedLabels { - found := false - for _, actual := range merged.Labels { - if actual == expected { - found = true - break - } - } - if !found { - t.Errorf("Expected label %q in merged labels %v", expected, merged.Labels) - } - } -} - -// TestLabelUnion_LocalOnly tests label union when only local adds labels -func TestLabelUnion_LocalOnly(t *testing.T) { - now := time.Now() - base := makeTestIssueWithLabels("bd-1234", "Test", types.StatusOpen, 1, now, []string{"original"}) - local := makeTestIssueWithLabels("bd-1234", "Test Local", types.StatusOpen, 1, now.Add(time.Hour), []string{"original", "local-added"}) - remote := makeTestIssueWithLabels("bd-1234", "Test Remote", types.StatusOpen, 1, now.Add(2*time.Hour), []string{"original"}) - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - - // Labels should include local-added even though remote is newer for scalars - expectedLabels := []string{"local-added", "original"} - if len(merged.Labels) != len(expectedLabels) { - t.Errorf("Expected %d labels, got %d: %v", len(expectedLabels), len(merged.Labels), merged.Labels) - } -} - -// TestLabelUnion_RemoteOnly tests label union when only remote adds labels -func TestLabelUnion_RemoteOnly(t *testing.T) { - now := time.Now() - base := makeTestIssueWithLabels("bd-1234", "Test", types.StatusOpen, 1, now, []string{"original"}) - local := makeTestIssueWithLabels("bd-1234", "Test Local", types.StatusOpen, 1, now.Add(2*time.Hour), []string{"original"}) - remote := makeTestIssueWithLabels("bd-1234", "Test Remote", types.StatusOpen, 1, now.Add(time.Hour), []string{"original", "remote-added"}) - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - - // Labels should include remote-added even though local is newer for scalars - expectedLabels := []string{"original", "remote-added"} - if len(merged.Labels) != len(expectedLabels) { - t.Errorf("Expected %d labels, got %d: %v", len(expectedLabels), len(merged.Labels), merged.Labels) - } -} - -// TestDependencyUnion tests dependency union when both add different dependencies -func TestDependencyUnion(t *testing.T) { - now := time.Now() - - localDep := &types.Dependency{ - IssueID: "bd-1234", - DependsOnID: "bd-aaaa", - Type: types.DepBlocks, - CreatedAt: now, - } - remoteDep := &types.Dependency{ - IssueID: "bd-1234", - DependsOnID: "bd-bbbb", - Type: types.DepBlocks, - CreatedAt: now, - } - - base := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Test Local", types.StatusInProgress, 1, now.Add(time.Hour)) - local.Dependencies = []*types.Dependency{localDep} - remote := makeTestIssue("bd-1234", "Test Remote", types.StatusClosed, 1, now.Add(2*time.Hour)) - remote.Dependencies = []*types.Dependency{remoteDep} - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - - // Dependencies should be union of both - if len(merged.Dependencies) != 2 { - t.Errorf("Expected 2 dependencies, got %d", len(merged.Dependencies)) - } - - // Check both dependencies are present - foundAAA := false - foundBBB := false - for _, dep := range merged.Dependencies { - if dep.DependsOnID == "bd-aaaa" { - foundAAA = true - } - if dep.DependsOnID == "bd-bbbb" { - foundBBB = true - } - } - if !foundAAA { - t.Error("Expected dependency to bd-aaaa in merged") - } - if !foundBBB { - t.Error("Expected dependency to bd-bbbb in merged") - } -} - -// TestCommentAppend tests comment append-merge with deduplication -func TestCommentAppend(t *testing.T) { - now := time.Now() - - // Common comment (should be deduplicated) - commonComment := &types.Comment{ - ID: 1, - IssueID: "bd-1234", - Author: "user1", - Text: "Common comment", - CreatedAt: now.Add(-time.Hour), - } - localComment := &types.Comment{ - ID: 2, - IssueID: "bd-1234", - Author: "user2", - Text: "Local comment", - CreatedAt: now, - } - remoteComment := &types.Comment{ - ID: 3, - IssueID: "bd-1234", - Author: "user3", - Text: "Remote comment", - CreatedAt: now.Add(30 * time.Minute), - } - - base := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now.Add(-2*time.Hour)) - base.Comments = []*types.Comment{commonComment} - - local := makeTestIssue("bd-1234", "Test Local", types.StatusInProgress, 1, now.Add(time.Hour)) - local.Comments = []*types.Comment{commonComment, localComment} - - remote := makeTestIssue("bd-1234", "Test Remote", types.StatusClosed, 1, now.Add(2*time.Hour)) - remote.Comments = []*types.Comment{commonComment, remoteComment} - - merged, strategy, _ := MergeIssue(base, local, remote) - - if strategy != StrategyMerged { - t.Errorf("Expected strategy=%s, got %s", StrategyMerged, strategy) - } - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - - // Comments should be union (3 total: common, local, remote) - if len(merged.Comments) != 3 { - t.Errorf("Expected 3 comments, got %d", len(merged.Comments)) - } - - // Check comments are sorted chronologically - for i := 0; i < len(merged.Comments)-1; i++ { - if merged.Comments[i].CreatedAt.After(merged.Comments[i+1].CreatedAt) { - t.Errorf("Comments not sorted chronologically: %v after %v", - merged.Comments[i].CreatedAt, merged.Comments[i+1].CreatedAt) - } - } -} - -// TestFieldMerge_EdgeCases tests edge cases in field-level merge -func TestFieldMerge_EdgeCases(t *testing.T) { - t.Run("nil_labels", func(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Test Local", types.StatusInProgress, 1, now.Add(time.Hour)) - local.Labels = nil - remote := makeTestIssue("bd-1234", "Test Remote", types.StatusClosed, 1, now.Add(2*time.Hour)) - remote.Labels = []string{"remote-label"} - - merged, _, _ := MergeIssue(base, local, remote) - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - - // Should have remote label (union of nil and ["remote-label"]) - if len(merged.Labels) != 1 || merged.Labels[0] != "remote-label" { - t.Errorf("Expected ['remote-label'], got %v", merged.Labels) - } - }) - - t.Run("empty_labels", func(t *testing.T) { - now := time.Now() - base := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Test Local", types.StatusInProgress, 1, now.Add(time.Hour)) - local.Labels = []string{} - remote := makeTestIssue("bd-1234", "Test Remote", types.StatusClosed, 1, now.Add(2*time.Hour)) - remote.Labels = []string{"remote-label"} - - merged, _, _ := MergeIssue(base, local, remote) - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - - // Should have remote label (union of [] and ["remote-label"]) - if len(merged.Labels) != 1 || merged.Labels[0] != "remote-label" { - t.Errorf("Expected ['remote-label'], got %v", merged.Labels) - } - }) - - t.Run("nil_dependencies", func(t *testing.T) { - now := time.Now() - dep := &types.Dependency{ - IssueID: "bd-1234", - DependsOnID: "bd-dep", - Type: types.DepBlocks, - CreatedAt: now, - } - - base := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Test Local", types.StatusInProgress, 1, now.Add(time.Hour)) - local.Dependencies = []*types.Dependency{dep} - remote := makeTestIssue("bd-1234", "Test Remote", types.StatusClosed, 1, now.Add(2*time.Hour)) - remote.Dependencies = nil - - merged, _, _ := MergeIssue(base, local, remote) - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - - // Should have the dependency from local - if len(merged.Dependencies) != 1 { - t.Errorf("Expected 1 dependency, got %d", len(merged.Dependencies)) - } - }) - - t.Run("nil_comments", func(t *testing.T) { - now := time.Now() - comment := &types.Comment{ - ID: 1, - IssueID: "bd-1234", - Author: "user", - Text: "Test comment", - CreatedAt: now, - } - - base := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now.Add(-time.Hour)) - local := makeTestIssue("bd-1234", "Test Local", types.StatusInProgress, 1, now.Add(time.Hour)) - local.Comments = nil - remote := makeTestIssue("bd-1234", "Test Remote", types.StatusClosed, 1, now.Add(2*time.Hour)) - remote.Comments = []*types.Comment{comment} - - merged, _, _ := MergeIssue(base, local, remote) - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - - // Should have the comment from remote - if len(merged.Comments) != 1 { - t.Errorf("Expected 1 comment, got %d", len(merged.Comments)) - } - }) - - t.Run("duplicate_dependencies_newer_wins", func(t *testing.T) { - now := time.Now() - - // Same dependency in both, but with different metadata/timestamps - localDep := &types.Dependency{ - IssueID: "bd-1234", - DependsOnID: "bd-dep", - Type: types.DepBlocks, - CreatedAt: now, - CreatedBy: "local-user", - } - remoteDep := &types.Dependency{ - IssueID: "bd-1234", - DependsOnID: "bd-dep", - Type: types.DepBlocks, - CreatedAt: now.Add(time.Hour), // Newer - CreatedBy: "remote-user", - } - - base := makeTestIssue("bd-1234", "Test", types.StatusOpen, 1, now.Add(-time.Hour)) - local := makeTestIssue("bd-1234", "Test Local", types.StatusInProgress, 1, now.Add(time.Hour)) - local.Dependencies = []*types.Dependency{localDep} - remote := makeTestIssue("bd-1234", "Test Remote", types.StatusClosed, 1, now.Add(2*time.Hour)) - remote.Dependencies = []*types.Dependency{remoteDep} - - merged, _, _ := MergeIssue(base, local, remote) - if merged == nil { - t.Fatal("Expected merged issue, got nil") - } - - // Should have only 1 dependency (deduplicated), the newer one - if len(merged.Dependencies) != 1 { - t.Errorf("Expected 1 dependency, got %d", len(merged.Dependencies)) - } - if merged.Dependencies[0].CreatedBy != "remote-user" { - t.Errorf("Expected newer dependency (remote-user), got %s", merged.Dependencies[0].CreatedBy) - } - }) -} - -// ============================================================================= -// Clock Skew Detection Tests (Phase 2 - PR918) -// ============================================================================= - -// TestMergeClockSkewWarning tests that large timestamp differences produce a warning -func TestMergeClockSkewWarning(t *testing.T) { - now := time.Now() - - t.Run("no_warning_under_24h", func(t *testing.T) { - base := makeTestIssue("bd-1234", "Original", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Local Update", types.StatusInProgress, 1, now.Add(23*time.Hour)) - remote := makeTestIssue("bd-1234", "Remote Update", types.StatusClosed, 1, now) - - // Capture stderr - oldStderr := os.Stderr - r, w, _ := os.Pipe() - os.Stderr = w - - _, _, _ = MergeIssue(base, local, remote) - - w.Close() - os.Stderr = oldStderr - var stderrBuf bytes.Buffer - stderrBuf.ReadFrom(r) - stderrOutput := stderrBuf.String() - - // Should NOT produce warning for <24h difference - if strings.Contains(stderrOutput, "clock skew") { - t.Errorf("Expected no warning for 23h difference, got: %s", stderrOutput) - } - }) - - t.Run("warning_over_24h_local_newer", func(t *testing.T) { - base := makeTestIssue("bd-1234", "Original", types.StatusOpen, 1, now) - local := makeTestIssue("bd-1234", "Local Update", types.StatusInProgress, 1, now.Add(48*time.Hour)) - remote := makeTestIssue("bd-1234", "Remote Update", types.StatusClosed, 1, now) - - // Capture stderr - oldStderr := os.Stderr - r, w, _ := os.Pipe() - os.Stderr = w - - _, _, _ = MergeIssue(base, local, remote) - - w.Close() - os.Stderr = oldStderr - var stderrBuf bytes.Buffer - stderrBuf.ReadFrom(r) - stderrOutput := stderrBuf.String() - - // Should produce warning for 48h difference - if !strings.Contains(stderrOutput, "clock skew") { - t.Errorf("Expected clock skew warning for 48h difference, got: %s", stderrOutput) - } - if !strings.Contains(stderrOutput, "bd-1234") { - t.Errorf("Warning should contain issue ID, got: %s", stderrOutput) - } - }) - - t.Run("warning_over_24h_remote_newer", func(t *testing.T) { - base := makeTestIssue("bd-5678", "Original", types.StatusOpen, 1, now) - local := makeTestIssue("bd-5678", "Local Update", types.StatusInProgress, 1, now) - remote := makeTestIssue("bd-5678", "Remote Update", types.StatusClosed, 1, now.Add(72*time.Hour)) - - // Capture stderr - oldStderr := os.Stderr - r, w, _ := os.Pipe() - os.Stderr = w - - _, _, _ = MergeIssue(base, local, remote) - - w.Close() - os.Stderr = oldStderr - var stderrBuf bytes.Buffer - stderrBuf.ReadFrom(r) - stderrOutput := stderrBuf.String() - - // Should produce warning for 72h difference - if !strings.Contains(stderrOutput, "clock skew") { - t.Errorf("Expected clock skew warning for 72h difference, got: %s", stderrOutput) - } - if !strings.Contains(stderrOutput, "bd-5678") { - t.Errorf("Warning should contain issue ID, got: %s", stderrOutput) - } - }) - - t.Run("warning_exactly_24h", func(t *testing.T) { - base := makeTestIssue("bd-exact", "Original", types.StatusOpen, 1, now) - local := makeTestIssue("bd-exact", "Local Update", types.StatusInProgress, 1, now.Add(24*time.Hour)) - remote := makeTestIssue("bd-exact", "Remote Update", types.StatusClosed, 1, now) - - // Capture stderr - oldStderr := os.Stderr - r, w, _ := os.Pipe() - os.Stderr = w - - _, _, _ = MergeIssue(base, local, remote) - - w.Close() - os.Stderr = oldStderr - var stderrBuf bytes.Buffer - stderrBuf.ReadFrom(r) - stderrOutput := stderrBuf.String() - - // Exactly 24h should NOT trigger warning (> not >=) - if strings.Contains(stderrOutput, "clock skew") { - t.Errorf("Expected no warning for exactly 24h difference, got: %s", stderrOutput) - } - }) -} - -// TestMergeLabels tests the mergeLabels helper function directly -func TestMergeLabels(t *testing.T) { - tests := []struct { - name string - local []string - remote []string - expected []string - }{ - { - name: "both_empty", - local: nil, - remote: nil, - expected: nil, - }, - { - name: "local_only", - local: []string{"a", "b"}, - remote: nil, - expected: []string{"a", "b"}, - }, - { - name: "remote_only", - local: nil, - remote: []string{"x", "y"}, - expected: []string{"x", "y"}, - }, - { - name: "no_overlap", - local: []string{"a", "b"}, - remote: []string{"x", "y"}, - expected: []string{"a", "b", "x", "y"}, - }, - { - name: "full_overlap", - local: []string{"a", "b"}, - remote: []string{"a", "b"}, - expected: []string{"a", "b"}, - }, - { - name: "partial_overlap", - local: []string{"a", "b", "c"}, - remote: []string{"b", "c", "d"}, - expected: []string{"a", "b", "c", "d"}, - }, - { - name: "duplicates_in_input", - local: []string{"a", "a", "b"}, - remote: []string{"b", "b", "c"}, - expected: []string{"a", "b", "c"}, - }, - } - - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - result := mergeLabels(tc.local, tc.remote) - - // Check length - if len(result) != len(tc.expected) { - t.Errorf("Expected %d labels, got %d: %v", len(tc.expected), len(result), result) - return - } - - // Check contents (result is sorted, so direct comparison works) - for i, expected := range tc.expected { - if i >= len(result) || result[i] != expected { - t.Errorf("Expected %v, got %v", tc.expected, result) - return - } - } - }) - } -} - -// TestMergeFieldLevel_CompactionLevel tests compaction_level uses max strategy by default -func TestMergeFieldLevel_CompactionLevel(t *testing.T) { - now := time.Now() - - t.Run("max_strategy_takes_higher_value", func(t *testing.T) { - // Local has higher compaction_level - local := makeTestIssue("bd-1234", "Local", types.StatusOpen, 1, now.Add(time.Hour)) - local.CompactionLevel = 5 - remote := makeTestIssue("bd-1234", "Remote", types.StatusOpen, 1, now) - remote.CompactionLevel = 3 - - merged, manualConflicts := mergeFieldLevel(nil, local, remote) - - if merged.CompactionLevel != 5 { - t.Errorf("Expected compaction_level=5 (max), got %d", merged.CompactionLevel) - } - if len(manualConflicts) != 0 { - t.Errorf("Expected no manual conflicts, got %d", len(manualConflicts)) - } - }) - - t.Run("max_strategy_takes_higher_from_remote", func(t *testing.T) { - // Remote has higher compaction_level - local := makeTestIssue("bd-1234", "Local", types.StatusOpen, 1, now.Add(time.Hour)) - local.CompactionLevel = 2 - remote := makeTestIssue("bd-1234", "Remote", types.StatusOpen, 1, now) - remote.CompactionLevel = 7 - - merged, manualConflicts := mergeFieldLevel(nil, local, remote) - - if merged.CompactionLevel != 7 { - t.Errorf("Expected compaction_level=7 (max), got %d", merged.CompactionLevel) - } - if len(manualConflicts) != 0 { - t.Errorf("Expected no manual conflicts, got %d", len(manualConflicts)) - } - }) -} - -// TestMergeFieldLevel_EstimatedMinutes tests estimated_minutes uses manual strategy by default -func TestMergeFieldLevel_EstimatedMinutes(t *testing.T) { - now := time.Now() - - t.Run("manual_strategy_flags_conflict_when_different", func(t *testing.T) { - // Default is manual strategy - should flag conflict when values differ - localMins := 120 - remoteMins := 60 - local := makeTestIssue("bd-1234", "Local", types.StatusOpen, 1, now.Add(time.Hour)) - local.EstimatedMinutes = &localMins - remote := makeTestIssue("bd-1234", "Remote", types.StatusOpen, 1, now) - remote.EstimatedMinutes = &remoteMins - - merged, manualConflicts := mergeFieldLevel(nil, local, remote) - - // Should keep local value as tentative - if merged.EstimatedMinutes == nil || *merged.EstimatedMinutes != 120 { - t.Errorf("Expected estimated_minutes=120 (local as tentative), got %v", merged.EstimatedMinutes) - } - // Should flag for manual resolution - if len(manualConflicts) != 1 { - t.Errorf("Expected 1 manual conflict, got %d", len(manualConflicts)) - } else { - mc := manualConflicts[0] - if mc.Field != "estimated_minutes" { - t.Errorf("Expected field=estimated_minutes, got %s", mc.Field) - } - if mc.LocalValue != 120 { - t.Errorf("Expected LocalValue=120, got %v", mc.LocalValue) - } - if mc.RemoteValue != 60 { - t.Errorf("Expected RemoteValue=60, got %v", mc.RemoteValue) - } - } - }) - - t.Run("manual_strategy_no_conflict_when_same", func(t *testing.T) { - // No conflict when values are the same - mins := 120 - local := makeTestIssue("bd-1234", "Local", types.StatusOpen, 1, now.Add(time.Hour)) - local.EstimatedMinutes = &mins - remote := makeTestIssue("bd-1234", "Remote", types.StatusOpen, 1, now) - remoteMins := 120 - remote.EstimatedMinutes = &remoteMins - - merged, manualConflicts := mergeFieldLevel(nil, local, remote) - - if merged.EstimatedMinutes == nil || *merged.EstimatedMinutes != 120 { - t.Errorf("Expected estimated_minutes=120, got %v", merged.EstimatedMinutes) - } - if len(manualConflicts) != 0 { - t.Errorf("Expected no manual conflicts when values match, got %d", len(manualConflicts)) - } - }) - - t.Run("manual_strategy_nil_vs_value_flags_conflict", func(t *testing.T) { - // Conflict when one is nil and other has value - remoteMins := 60 - local := makeTestIssue("bd-1234", "Local", types.StatusOpen, 1, now.Add(time.Hour)) - local.EstimatedMinutes = nil - remote := makeTestIssue("bd-1234", "Remote", types.StatusOpen, 1, now) - remote.EstimatedMinutes = &remoteMins - - merged, manualConflicts := mergeFieldLevel(nil, local, remote) - - // Should keep local value (nil) as tentative - if merged.EstimatedMinutes != nil { - t.Errorf("Expected estimated_minutes=nil (local as tentative), got %v", *merged.EstimatedMinutes) - } - // Should flag for manual resolution - if len(manualConflicts) != 1 { - t.Errorf("Expected 1 manual conflict, got %d", len(manualConflicts)) - } - }) -} - -// TestMaxInt tests the maxInt helper function -func TestMaxInt(t *testing.T) { - tests := []struct { - a, b, expected int - }{ - {0, 0, 0}, - {1, 0, 1}, - {0, 1, 1}, - {5, 3, 5}, - {3, 5, 5}, - {-1, -2, -1}, - {-2, -1, -1}, - } - - for _, tc := range tests { - result := maxInt(tc.a, tc.b) - if result != tc.expected { - t.Errorf("maxInt(%d, %d) = %d, expected %d", tc.a, tc.b, result, tc.expected) - } - } -} - -// TestMaxIntPtr tests the maxIntPtr helper function -func TestMaxIntPtr(t *testing.T) { - five := 5 - three := 3 - - t.Run("both_nil_returns_nil", func(t *testing.T) { - result := maxIntPtr(nil, nil) - if result != nil { - t.Errorf("Expected nil, got %v", result) - } - }) - - t.Run("left_nil_returns_right", func(t *testing.T) { - result := maxIntPtr(nil, &three) - if result == nil || *result != 3 { - t.Errorf("Expected 3, got %v", result) - } - }) - - t.Run("right_nil_returns_left", func(t *testing.T) { - result := maxIntPtr(&five, nil) - if result == nil || *result != 5 { - t.Errorf("Expected 5, got %v", result) - } - }) - - t.Run("returns_larger_value", func(t *testing.T) { - result := maxIntPtr(&three, &five) - if result == nil || *result != 5 { - t.Errorf("Expected 5, got %v", result) - } - - result = maxIntPtr(&five, &three) - if result == nil || *result != 5 { - t.Errorf("Expected 5, got %v", result) - } - }) -} - -// TestMergeResult_ManualConflicts tests that ManualConflicts is properly initialized -func TestMergeResult_ManualConflicts(t *testing.T) { - now := time.Now() - base := []*types.Issue{ - makeTestIssue("bd-1234", "Base", types.StatusOpen, 1, now), - } - local := []*types.Issue{ - makeTestIssue("bd-1234", "Local", types.StatusOpen, 1, now.Add(time.Hour)), - } - remote := []*types.Issue{ - makeTestIssue("bd-1234", "Remote", types.StatusOpen, 1, now.Add(2*time.Hour)), - } - - result := MergeIssues(base, local, remote) - - if result.ManualConflicts == nil { - t.Error("ManualConflicts should be initialized, got nil") - } -} diff --git a/cmd/bd/sync_mode.go b/cmd/bd/sync_mode.go deleted file mode 100644 index f9ee45e72..000000000 --- a/cmd/bd/sync_mode.go +++ /dev/null @@ -1,149 +0,0 @@ -package main - -import ( - "context" - "fmt" - - "github.com/steveyegge/beads/internal/config" - "github.com/steveyegge/beads/internal/storage/dolt" -) - -// Sync mode constants - re-exported from internal/config for backward compatibility. -// These are used with *dolt.DoltStore (database) while config.SyncMode* are used -// with viper (config.yaml). -const ( - // SyncModeGitPortable exports to JSONL on push, imports on pull. - // This is the default mode - works with standard git workflows. - SyncModeGitPortable = string(config.SyncModeGitPortable) - - // SyncModeRealtime exports to JSONL on every database mutation. - // Provides immediate persistence but more git noise. - SyncModeRealtime = string(config.SyncModeRealtime) - - // SyncModeDoltNative uses Dolt remotes for sync, no JSONL writes. - // Requires Dolt backend and configured Dolt remote. - SyncModeDoltNative = string(config.SyncModeDoltNative) - - // SyncModeBeltAndSuspenders uses both Dolt remotes AND JSONL. - // Maximum redundancy - Dolt for versioning, JSONL for git portability. - SyncModeBeltAndSuspenders = string(config.SyncModeBeltAndSuspenders) - - // SyncModeConfigKey is the database config key for sync mode. - SyncModeConfigKey = "sync.mode" - - // SyncExportOnConfigKey controls when JSONL export happens. - SyncExportOnConfigKey = "sync.export_on" - - // SyncImportOnConfigKey controls when JSONL import happens. - SyncImportOnConfigKey = "sync.import_on" -) - -// Trigger constants for export_on and import_on settings. -const ( - // TriggerPush triggers on git push (export) or git pull (import). - TriggerPush = "push" - TriggerPull = "pull" - - // TriggerChange triggers on every database mutation (realtime mode). - TriggerChange = "change" -) - -// GetSyncMode returns the configured sync mode, checking config.yaml first (where bd config set writes), -// then falling back to database. This fixes GH#1277 where yaml and database were inconsistent. -func GetSyncMode(ctx context.Context, s *dolt.DoltStore) string { - // First check config.yaml (where bd config set writes for sync.* keys) - yamlMode := config.GetSyncMode() - if yamlMode != "" && yamlMode != config.SyncModeGitPortable { - // Non-default value in yaml takes precedence - return string(yamlMode) - } - - // Fall back to database (legacy path) - mode, err := s.GetConfig(ctx, SyncModeConfigKey) - if err != nil || mode == "" { - return SyncModeGitPortable - } - - // Validate mode using the shared validation - if !config.IsValidSyncMode(mode) { - return SyncModeGitPortable - } - - return mode -} - -// SetSyncMode sets the sync mode configuration in the database. -func SetSyncMode(ctx context.Context, s *dolt.DoltStore, mode string) error { - // Validate mode using the shared validation - if !config.IsValidSyncMode(mode) { - return fmt.Errorf("invalid sync mode: %s (valid: %s)", - mode, fmt.Sprintf("%v", config.ValidSyncModes())) - } - - return s.SetConfig(ctx, SyncModeConfigKey, mode) -} - -// GetExportTrigger returns when JSONL export should happen. -func GetExportTrigger(ctx context.Context, s *dolt.DoltStore) string { - trigger, err := s.GetConfig(ctx, SyncExportOnConfigKey) - if err != nil || trigger == "" { - // Default based on sync mode - mode := GetSyncMode(ctx, s) - if mode == SyncModeRealtime { - return TriggerChange - } - return TriggerPush - } - return trigger -} - -// GetImportTrigger returns when JSONL import should happen. -func GetImportTrigger(ctx context.Context, s *dolt.DoltStore) string { - trigger, err := s.GetConfig(ctx, SyncImportOnConfigKey) - if err != nil || trigger == "" { - return TriggerPull - } - return trigger -} - -// ShouldExportJSONL returns true if the current sync mode uses JSONL export. -// In dolt-native mode, JSONL is not used — all sync is via Dolt remotes. -// Belt-and-suspenders mode uses both Dolt AND JSONL for maximum redundancy. -// -// Uses GetSyncMode which checks config.yaml first, then falls back to the database. -// This ensures that sync.mode set in config.yaml (e.g. during Dolt migration) is -// respected even if not yet propagated to the database via 'bd sync mode set'. -func ShouldExportJSONL(ctx context.Context, s *dolt.DoltStore) bool { - mode := GetSyncMode(ctx, s) - return mode != SyncModeDoltNative -} - -// ShouldImportJSONL returns true if the current sync mode uses JSONL import. -// In dolt-native mode, there is no JSONL to import — all sync is via Dolt remotes. -// Uses GetSyncMode which checks config.yaml first, then falls back to the database. -func ShouldImportJSONL(ctx context.Context, s *dolt.DoltStore) bool { - mode := GetSyncMode(ctx, s) - return mode != SyncModeDoltNative -} - -// ShouldUseDoltRemote returns true if the current sync mode uses Dolt remotes. -func ShouldUseDoltRemote(ctx context.Context, s *dolt.DoltStore) bool { - mode := GetSyncMode(ctx, s) - return mode == SyncModeDoltNative || mode == SyncModeBeltAndSuspenders -} - -// SyncModeDescription returns a human-readable description of the sync mode. -func SyncModeDescription(mode string) string { - switch mode { - case SyncModeGitPortable: - return "JSONL exported on push, imported on pull" - case SyncModeRealtime: - return "JSONL exported on every change" - case SyncModeDoltNative: - return "Dolt remotes for sync, no JSONL writes" - case SyncModeBeltAndSuspenders: - return "Both Dolt remotes and JSONL" - default: - return "unknown mode" - } -} diff --git a/cmd/bd/sync_mode_cmd.go b/cmd/bd/sync_mode_cmd.go deleted file mode 100644 index 6ce48eaa6..000000000 --- a/cmd/bd/sync_mode_cmd.go +++ /dev/null @@ -1,191 +0,0 @@ -package main - -import ( - "fmt" - "os" - "strings" - - "github.com/spf13/cobra" - "github.com/steveyegge/beads/internal/config" -) - -// Sync mode info for display -var syncModeInfo = []struct { - Mode string - Description string -}{ - {SyncModeGitPortable, "JSONL exported on push, imported on pull (default)"}, - {SyncModeRealtime, "JSONL exported on every change (more git noise)"}, - {SyncModeDoltNative, "Dolt remotes for sync, JSONL export-only backup (requires Dolt backend)"}, - {SyncModeBeltAndSuspenders, "Both Dolt remotes and JSONL (maximum redundancy)"}, -} - -var syncModeCmd = &cobra.Command{ - Use: "mode", - Short: "Manage sync mode configuration", - Long: `Manage sync mode configuration. - -Sync mode controls how beads synchronizes data with git: - - git-portable (default) - JSONL exported on push, imported on pull. - Works with standard git workflows. - - realtime - JSONL exported on every database change. - Provides immediate persistence but more git noise. - - dolt-native - Dolt remotes for sync, JSONL export-only (backup). - Requires Dolt backend and configured Dolt remote. - - belt-and-suspenders - Uses both Dolt remotes AND JSONL. - Maximum redundancy - Dolt for versioning, JSONL for git portability. - -Commands: - bd sync mode list List available sync modes - bd sync mode current Show current sync mode - bd sync mode set Set sync mode`, -} - -var syncModeListCmd = &cobra.Command{ - Use: "list", - Short: "List available sync modes", - Long: `List all available sync modes and their descriptions. - -Sync modes control how beads synchronizes with git and Dolt remotes.`, - Run: func(cmd *cobra.Command, args []string) { - if jsonOutput { - modes := make([]map[string]string, len(syncModeInfo)) - for i, m := range syncModeInfo { - modes[i] = map[string]string{ - "mode": m.Mode, - "description": m.Description, - } - } - outputJSON(map[string]interface{}{ - "modes": modes, - }) - return - } - - fmt.Println("Available sync modes:") - for _, m := range syncModeInfo { - fmt.Printf(" %-22s %s\n", m.Mode, m.Description) - } - fmt.Println("\nSet sync mode: bd sync mode set ") - }, -} - -var syncModeCurrentCmd = &cobra.Command{ - Use: "current", - Short: "Show current sync mode", - Long: `Show the currently configured sync mode.`, - Run: func(cmd *cobra.Command, args []string) { - // Try to get from database if available - var currentMode string - if store != nil { - currentMode = GetSyncMode(rootCtx, store) - } else { - // Fall back to config.yaml - currentMode = string(config.GetSyncMode()) - } - - if jsonOutput { - result := map[string]interface{}{ - "mode": currentMode, - } - // Add description - for _, m := range syncModeInfo { - if m.Mode == currentMode { - result["description"] = m.Description - break - } - } - outputJSON(result) - return - } - - fmt.Printf("Current sync mode: %s\n", currentMode) - // Show description - for _, m := range syncModeInfo { - if m.Mode == currentMode { - fmt.Printf(" %s\n", m.Description) - break - } - } - }, -} - -var syncModeSetCmd = &cobra.Command{ - Use: "set ", - Short: "Set sync mode", - Long: `Set the sync mode. - -Valid modes: - git-portable JSONL exported on push, imported on pull (default) - realtime JSONL exported on every change - dolt-native Dolt remotes for sync, JSONL export-only backup (requires Dolt backend) - belt-and-suspenders Both Dolt remotes and JSONL - -Example: - bd sync mode set realtime - bd sync mode set dolt-native`, - Args: cobra.ExactArgs(1), - Run: func(cmd *cobra.Command, args []string) { - CheckReadonly("sync mode set") - - mode := strings.TrimSpace(args[0]) - - // Validate mode - if !config.IsValidSyncMode(mode) { - fmt.Fprintf(os.Stderr, "Error: invalid sync mode: %s\n", mode) - fmt.Fprintf(os.Stderr, "Valid modes: %s\n", strings.Join(config.ValidSyncModes(), ", ")) - os.Exit(1) - } - - // Require direct mode for database writes - if err := ensureDirectMode("sync mode set requires direct database access"); err != nil { - fmt.Fprintf(os.Stderr, "Error: %v\n", err) - os.Exit(1) - } - - // Set the mode - if err := SetSyncMode(rootCtx, store, mode); err != nil { - fmt.Fprintf(os.Stderr, "Error setting sync mode: %v\n", err) - os.Exit(1) - } - - if jsonOutput { - result := map[string]interface{}{ - "mode": mode, - } - // Add description - for _, m := range syncModeInfo { - if m.Mode == mode { - result["description"] = m.Description - break - } - } - outputJSON(result) - return - } - - fmt.Printf("Sync mode set to: %s\n", mode) - // Show description - for _, m := range syncModeInfo { - if m.Mode == mode { - fmt.Printf(" %s\n", m.Description) - break - } - } - }, -} - -func init() { - syncModeCmd.AddCommand(syncModeListCmd) - syncModeCmd.AddCommand(syncModeCurrentCmd) - syncModeCmd.AddCommand(syncModeSetCmd) - syncCmd.AddCommand(syncModeCmd) -} diff --git a/cmd/bd/sync_mode_cmd_test.go b/cmd/bd/sync_mode_cmd_test.go deleted file mode 100644 index 1ed198766..000000000 --- a/cmd/bd/sync_mode_cmd_test.go +++ /dev/null @@ -1,391 +0,0 @@ -//go:build cgo - -package main - -import ( - "bytes" - "context" - "encoding/json" - "io" - "os" - "path/filepath" - "strings" - "testing" - - "github.com/steveyegge/beads/internal/config" - "github.com/steveyegge/beads/internal/storage/dolt" -) - -// TestSyncModeListText tests `bd sync mode list` text output. -func TestSyncModeListText(t *testing.T) { - // Save original state - origJsonOutput := jsonOutput - defer func() { jsonOutput = origJsonOutput }() - jsonOutput = false - - // Capture stdout - output := captureSyncModeListOutput(t) - - // Verify output contains all sync modes - for _, mode := range config.ValidSyncModes() { - if !strings.Contains(output, mode) { - t.Errorf("output should contain mode '%s', got: %s", mode, output) - } - } - - // Verify header - if !strings.Contains(output, "Available sync modes") { - t.Error("output should contain 'Available sync modes' header") - } - - // Verify usage hint - if !strings.Contains(output, "bd sync mode set") { - t.Error("output should contain usage hint") - } -} - -// TestSyncModeListJSON tests `bd sync mode list --json` output. -func TestSyncModeListJSON(t *testing.T) { - // Save original state - origJsonOutput := jsonOutput - defer func() { jsonOutput = origJsonOutput }() - jsonOutput = true - - // Capture stdout - output := captureSyncModeListOutput(t) - - // Parse JSON - var result struct { - Modes []struct { - Mode string `json:"mode"` - Description string `json:"description"` - } `json:"modes"` - } - if err := json.Unmarshal([]byte(output), &result); err != nil { - t.Fatalf("failed to parse JSON output: %v\nOutput: %s", err, output) - } - - // Verify we have 4 modes - if len(result.Modes) != 4 { - t.Errorf("expected 4 modes, got %d", len(result.Modes)) - } - - // Verify mode names match valid sync modes - modes := make(map[string]bool) - for _, m := range result.Modes { - modes[m.Mode] = true - if m.Description == "" { - t.Errorf("mode %s has empty description", m.Mode) - } - } - - for _, expected := range config.ValidSyncModes() { - if !modes[expected] { - t.Errorf("missing mode: %s", expected) - } - } -} - -// TestSyncModeCurrentWithStore tests `bd sync mode current` with a database. -func TestSyncModeCurrentWithStore(t *testing.T) { - ctx := context.Background() - tmpDir := t.TempDir() - - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("failed to create .beads dir: %v", err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - defer testStore.Close() - - // Set a specific sync mode - if err := SetSyncMode(ctx, testStore, SyncModeRealtime); err != nil { - t.Fatalf("failed to set sync mode: %v", err) - } - - // Save and restore global store and rootCtx - origStore := store - origStoreActive := storeActive - origRootCtx := rootCtx - defer func() { - storeMutex.Lock() - store = origStore - storeActive = origStoreActive - storeMutex.Unlock() - rootCtx = origRootCtx - }() - - storeMutex.Lock() - store = testStore - storeActive = true - storeMutex.Unlock() - rootCtx = ctx - - // Test text output - t.Run("text", func(t *testing.T) { - origJsonOutput := jsonOutput - defer func() { jsonOutput = origJsonOutput }() - jsonOutput = false - - output := captureSyncModeCurrentOutput(t) - - if !strings.Contains(output, "realtime") { - t.Errorf("output should contain 'realtime', got: %s", output) - } - if !strings.Contains(output, "Current sync mode") { - t.Errorf("output should contain 'Current sync mode', got: %s", output) - } - }) - - // Test JSON output - t.Run("json", func(t *testing.T) { - origJsonOutput := jsonOutput - defer func() { jsonOutput = origJsonOutput }() - jsonOutput = true - - output := captureSyncModeCurrentOutput(t) - - var result map[string]interface{} - if err := json.Unmarshal([]byte(output), &result); err != nil { - t.Fatalf("failed to parse JSON: %v\nOutput: %s", err, output) - } - - if result["mode"] != "realtime" { - t.Errorf("expected mode 'realtime', got %v", result["mode"]) - } - if result["description"] == nil { - t.Error("expected description in output") - } - }) -} - -// TestSyncModeCurrentWithoutStore tests `bd sync mode current` without a database. -func TestSyncModeCurrentWithoutStore(t *testing.T) { - // Save and restore global store - origStore := store - origStoreActive := storeActive - defer func() { - storeMutex.Lock() - store = origStore - storeActive = origStoreActive - storeMutex.Unlock() - }() - - storeMutex.Lock() - store = nil - storeActive = false - storeMutex.Unlock() - - // Suppress config warnings for cleaner test output - origWarnings := config.ConfigWarnings - config.ConfigWarnings = false - defer func() { config.ConfigWarnings = origWarnings }() - - // Test text output - should fall back to config.yaml (default: git-portable) - t.Run("text", func(t *testing.T) { - origJsonOutput := jsonOutput - defer func() { jsonOutput = origJsonOutput }() - jsonOutput = false - - output := captureSyncModeCurrentOutput(t) - - // Should show default mode when no store - if !strings.Contains(output, "git-portable") { - t.Errorf("output should contain 'git-portable' (default), got: %s", output) - } - }) - - // Test JSON output - t.Run("json", func(t *testing.T) { - origJsonOutput := jsonOutput - defer func() { jsonOutput = origJsonOutput }() - jsonOutput = true - - output := captureSyncModeCurrentOutput(t) - - var result map[string]interface{} - if err := json.Unmarshal([]byte(output), &result); err != nil { - t.Fatalf("failed to parse JSON: %v\nOutput: %s", err, output) - } - - if result["mode"] != "git-portable" { - t.Errorf("expected mode 'git-portable', got %v", result["mode"]) - } - }) -} - -// TestSyncModeInfoStructure verifies the syncModeInfo slice is well-formed. -func TestSyncModeInfoStructure(t *testing.T) { - if len(syncModeInfo) != 4 { - t.Errorf("expected 4 sync modes, got %d", len(syncModeInfo)) - } - - for i, m := range syncModeInfo { - if m.Mode == "" { - t.Errorf("syncModeInfo[%d] has empty Mode", i) - } - if m.Description == "" { - t.Errorf("syncModeInfo[%d] has empty Description", i) - } - } - - // Verify all valid sync modes are present - modes := make(map[string]bool) - for _, m := range syncModeInfo { - modes[m.Mode] = true - } - - for _, expected := range config.ValidSyncModes() { - if !modes[expected] { - t.Errorf("syncModeInfo missing mode: %s", expected) - } - } -} - -// TestSyncModeSetValidModes tests `bd sync mode set` with valid modes. -func TestSyncModeSetValidModes(t *testing.T) { - for _, mode := range config.ValidSyncModes() { - t.Run(mode, func(t *testing.T) { - ctx := context.Background() - tmpDir := t.TempDir() - - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("failed to create .beads dir: %v", err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - defer testStore.Close() - - // Set the mode - if err := SetSyncMode(ctx, testStore, mode); err != nil { - t.Fatalf("failed to set sync mode %s: %v", mode, err) - } - - // Verify it was set correctly - got := GetSyncMode(ctx, testStore) - if got != mode { - t.Errorf("GetSyncMode() = %q, want %q", got, mode) - } - }) - } -} - -// TestSyncModeSetInvalidMode tests `bd sync mode set` with an invalid mode. -func TestSyncModeSetInvalidMode(t *testing.T) { - ctx := context.Background() - tmpDir := t.TempDir() - - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("failed to create .beads dir: %v", err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - defer testStore.Close() - - // Try to set invalid mode - err = SetSyncMode(ctx, testStore, "invalid-mode") - if err == nil { - t.Error("expected error for invalid mode, got nil") - } - - // Verify error message mentions valid modes - if err != nil && !strings.Contains(err.Error(), "invalid") { - t.Errorf("error should mention 'invalid', got: %v", err) - } -} - -// TestSyncModeSetReadonly tests that `bd sync mode set` fails in readonly mode. -func TestSyncModeSetReadonly(t *testing.T) { - // Save and restore readonly mode - origReadonly := readonlyMode - defer func() { readonlyMode = origReadonly }() - - readonlyMode = true - - // The actual command would call CheckReadonly and exit - // We just verify the readonly flag is checked - if !readonlyMode { - t.Error("readonly mode should be enabled") - } - - // In real usage, syncModeSetCmd.Run calls CheckReadonly("sync mode set") - // which would call FatalError. We can't easily test os.Exit, but we - // verify the readonly guard exists by checking the code path. -} - -// TestSyncModeValidation tests the IsValidSyncMode helper. -func TestSyncModeValidation(t *testing.T) { - tests := []struct { - mode string - valid bool - }{ - {"git-portable", true}, - {"realtime", true}, - {"dolt-native", true}, - {"belt-and-suspenders", true}, - {"GIT-PORTABLE", true}, // Case insensitive - {"Git-Portable", true}, // Case insensitive - {" realtime ", true}, // Whitespace trimmed - {"invalid", false}, - {"", false}, - {"git portable", false}, // Space not hyphen - } - - for _, tt := range tests { - t.Run(tt.mode, func(t *testing.T) { - got := config.IsValidSyncMode(tt.mode) - if got != tt.valid { - t.Errorf("IsValidSyncMode(%q) = %v, want %v", tt.mode, got, tt.valid) - } - }) - } -} - -// captureSyncModeListOutput runs the sync mode list command and captures stdout. -func captureSyncModeListOutput(t *testing.T) string { - t.Helper() - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - - syncModeListCmd.Run(syncModeListCmd, []string{}) - - w.Close() - var buf bytes.Buffer - io.Copy(&buf, r) - os.Stdout = oldStdout - - return buf.String() -} - -// captureSyncModeCurrentOutput runs the sync mode current command and captures stdout. -func captureSyncModeCurrentOutput(t *testing.T) string { - t.Helper() - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - - syncModeCurrentCmd.Run(syncModeCurrentCmd, []string{}) - - w.Close() - var buf bytes.Buffer - io.Copy(&buf, r) - os.Stdout = oldStdout - - return buf.String() -} diff --git a/cmd/bd/sync_mode_test.go b/cmd/bd/sync_mode_test.go deleted file mode 100644 index f943b8c76..000000000 --- a/cmd/bd/sync_mode_test.go +++ /dev/null @@ -1,271 +0,0 @@ -//go:build cgo - -package main - -import ( - "context" - "os" - "path/filepath" - "testing" - - "github.com/steveyegge/beads/internal/storage/dolt" -) - -// TestSyncModeConfig verifies sync mode configuration storage and retrieval. -func TestSyncModeConfig(t *testing.T) { - ctx := context.Background() - tmpDir := t.TempDir() - - // Create .beads directory - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - // Create store - dbPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - defer testStore.Close() - - // Test 1: Default mode is git-portable - mode := GetSyncMode(ctx, testStore) - if mode != SyncModeGitPortable { - t.Errorf("default sync mode = %q, want %q", mode, SyncModeGitPortable) - } - t.Logf("✓ Default sync mode is git-portable") - - // Test 2: Set and get realtime mode - if err := SetSyncMode(ctx, testStore, SyncModeRealtime); err != nil { - t.Fatalf("failed to set sync mode: %v", err) - } - mode = GetSyncMode(ctx, testStore) - if mode != SyncModeRealtime { - t.Errorf("sync mode = %q, want %q", mode, SyncModeRealtime) - } - t.Logf("✓ Can set and get realtime mode") - - // Test 3: Set and get dolt-native mode - if err := SetSyncMode(ctx, testStore, SyncModeDoltNative); err != nil { - t.Fatalf("failed to set sync mode: %v", err) - } - mode = GetSyncMode(ctx, testStore) - if mode != SyncModeDoltNative { - t.Errorf("sync mode = %q, want %q", mode, SyncModeDoltNative) - } - t.Logf("✓ Can set and get dolt-native mode") - - // Test 4: Set and get belt-and-suspenders mode - if err := SetSyncMode(ctx, testStore, SyncModeBeltAndSuspenders); err != nil { - t.Fatalf("failed to set sync mode: %v", err) - } - mode = GetSyncMode(ctx, testStore) - if mode != SyncModeBeltAndSuspenders { - t.Errorf("sync mode = %q, want %q", mode, SyncModeBeltAndSuspenders) - } - t.Logf("✓ Can set and get belt-and-suspenders mode") - - // Test 5: Invalid mode returns error - err = SetSyncMode(ctx, testStore, "invalid-mode") - if err == nil { - t.Error("expected error for invalid sync mode") - } - t.Logf("✓ Invalid mode correctly rejected") - - // Test 6: Invalid mode in DB defaults to git-portable - if err := testStore.SetConfig(ctx, SyncModeConfigKey, "invalid"); err != nil { - t.Fatalf("failed to set invalid config: %v", err) - } - mode = GetSyncMode(ctx, testStore) - if mode != SyncModeGitPortable { - t.Errorf("invalid mode should default to %q, got %q", SyncModeGitPortable, mode) - } - t.Logf("✓ Invalid mode in DB defaults to git-portable") -} - -// TestShouldExportJSONL verifies JSONL export behavior per mode. -func TestShouldExportJSONL(t *testing.T) { - ctx := context.Background() - tmpDir := t.TempDir() - - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - defer testStore.Close() - - tests := []struct { - mode string - wantExport bool - }{ - {SyncModeGitPortable, true}, - {SyncModeRealtime, true}, - {SyncModeDoltNative, false}, // dolt-native uses Dolt remotes, not JSONL - {SyncModeBeltAndSuspenders, true}, - } - - for _, tt := range tests { - t.Run(tt.mode, func(t *testing.T) { - if err := SetSyncMode(ctx, testStore, tt.mode); err != nil { - t.Fatalf("failed to set mode: %v", err) - } - - got := ShouldExportJSONL(ctx, testStore) - if got != tt.wantExport { - t.Errorf("ShouldExportJSONL() = %v, want %v", got, tt.wantExport) - } - }) - } -} - -// TestShouldExportJSONL_UsesGetSyncMode verifies ShouldExportJSONL uses GetSyncMode -// (which checks config.yaml first, then DB). This ensures that sync.mode set in -// config.yaml is respected even when not propagated to the database — fixing the -// bug where dolt-native workspaces paid 10-25s JSONL export overhead (bd-6fiwk). -func TestShouldExportJSONL_UsesGetSyncMode(t *testing.T) { - ctx := context.Background() - tmpDir := t.TempDir() - - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - defer testStore.Close() - - // Set dolt-native in database — ShouldExportJSONL must return false - if err := testStore.SetConfig(ctx, SyncModeConfigKey, SyncModeDoltNative); err != nil { - t.Fatalf("failed to set config: %v", err) - } - if ShouldExportJSONL(ctx, testStore) { - t.Error("ShouldExportJSONL() = true, want false for dolt-native in DB") - } - - // Default (no config set) should return true - if err := testStore.SetConfig(ctx, SyncModeConfigKey, ""); err != nil { - t.Fatalf("failed to clear config: %v", err) - } - if !ShouldExportJSONL(ctx, testStore) { - t.Error("ShouldExportJSONL() = false, want true for default (no config)") - } -} - -// TestShouldImportJSONL verifies JSONL import behavior per mode. -func TestShouldImportJSONL(t *testing.T) { - ctx := context.Background() - tmpDir := t.TempDir() - - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - defer testStore.Close() - - tests := []struct { - mode string - wantImport bool - }{ - {SyncModeGitPortable, true}, - {SyncModeRealtime, true}, - {SyncModeDoltNative, false}, - {SyncModeBeltAndSuspenders, true}, - } - - for _, tt := range tests { - t.Run(tt.mode, func(t *testing.T) { - if err := SetSyncMode(ctx, testStore, tt.mode); err != nil { - t.Fatalf("failed to set mode: %v", err) - } - - got := ShouldImportJSONL(ctx, testStore) - if got != tt.wantImport { - t.Errorf("ShouldImportJSONL() = %v, want %v", got, tt.wantImport) - } - }) - } -} - -// TestShouldUseDoltRemote verifies Dolt remote usage per mode. -func TestShouldUseDoltRemote(t *testing.T) { - ctx := context.Background() - tmpDir := t.TempDir() - - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - defer testStore.Close() - - tests := []struct { - mode string - wantUse bool - }{ - {SyncModeGitPortable, false}, - {SyncModeRealtime, false}, - {SyncModeDoltNative, true}, - {SyncModeBeltAndSuspenders, true}, - } - - for _, tt := range tests { - t.Run(tt.mode, func(t *testing.T) { - if err := SetSyncMode(ctx, testStore, tt.mode); err != nil { - t.Fatalf("failed to set mode: %v", err) - } - - got := ShouldUseDoltRemote(ctx, testStore) - if got != tt.wantUse { - t.Errorf("ShouldUseDoltRemote() = %v, want %v", got, tt.wantUse) - } - }) - } -} - -// TestSyncModeDescription verifies mode descriptions are meaningful. -func TestSyncModeDescription(t *testing.T) { - tests := []struct { - mode string - wantContain string - }{ - {SyncModeGitPortable, "JSONL"}, - {SyncModeRealtime, "every change"}, - {SyncModeDoltNative, "export-only"}, - {SyncModeBeltAndSuspenders, "Both"}, - {"invalid", "unknown"}, - } - - for _, tt := range tests { - t.Run(tt.mode, func(t *testing.T) { - desc := SyncModeDescription(tt.mode) - if desc == "" { - t.Error("description should not be empty") - } - // Just verify descriptions are non-empty and distinct - t.Logf("%s: %s", tt.mode, desc) - }) - } -} diff --git a/cmd/bd/sync_modes_test.go b/cmd/bd/sync_modes_test.go deleted file mode 100644 index 0899513e8..000000000 --- a/cmd/bd/sync_modes_test.go +++ /dev/null @@ -1,856 +0,0 @@ -//go:build cgo - -package main - -import ( - "context" - "os" - "os/exec" - "path/filepath" - "strings" - "testing" - "time" - - "github.com/steveyegge/beads/internal/beads" - "github.com/steveyegge/beads/internal/git" - "github.com/steveyegge/beads/internal/storage/dolt" - "github.com/steveyegge/beads/internal/syncbranch" - "github.com/steveyegge/beads/internal/types" -) - -// TestSyncBranchModeWithPullFirst verifies that sync-branch mode config storage -// and retrieval works correctly. The pull-first sync gates on this config. -// This addresses Steve's review concern about --sync-branch regression. -func TestSyncBranchModeWithPullFirst(t *testing.T) { - ctx := context.Background() - tmpDir, cleanup := setupGitRepo(t) - defer cleanup() - - // Setup: Create beads directory with database - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - // Create store and configure sync.branch - testDBPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: testDBPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - defer testStore.Close() - - // Set issue prefix (required) - if err := testStore.SetConfig(ctx, "issue_prefix", "test"); err != nil { - t.Fatalf("failed to set issue_prefix: %v", err) - } - - // Configure sync.branch - if err := testStore.SetConfig(ctx, "sync.branch", "beads-metadata"); err != nil { - t.Fatalf("failed to set sync.branch: %v", err) - } - - // Create the sync branch in git - if err := exec.Command("git", "branch", "beads-metadata").Run(); err != nil { - t.Fatalf("failed to create sync branch: %v", err) - } - - // Create issues.jsonl with a test issue - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - issueContent := `{"id":"test-1","title":"Test Issue","status":"open","issue_type":"task","priority":2,"created_at":"2025-01-01T00:00:00Z","updated_at":"2025-01-01T00:00:00Z"}` - if err := os.WriteFile(jsonlPath, []byte(issueContent+"\n"), 0644); err != nil { - t.Fatalf("write JSONL failed: %v", err) - } - - // Test 1: Verify sync.branch config is stored and retrievable - // This is what the pull-first sync checks at lines 181-189 in sync.go - syncBranch, err := testStore.GetConfig(ctx, "sync.branch") - if err != nil { - t.Fatalf("failed to get sync.branch config: %v", err) - } - if syncBranch != "beads-metadata" { - t.Errorf("sync.branch = %q, want %q", syncBranch, "beads-metadata") - } - t.Logf("✓ Sync-branch config correctly stored: %s", syncBranch) - - // Test 2: Verify the git branch exists - checkCmd := exec.Command("git", "show-ref", "--verify", "--quiet", "refs/heads/beads-metadata") - if err := checkCmd.Run(); err != nil { - t.Error("expected beads-metadata branch to exist") - } - t.Log("✓ Git sync branch exists") - - // Test 3: Verify the DB config key can be read directly by syncbranch package - // Note: syncbranch.Get() also checks config.yaml and env var, which may override - // the DB config in the beads repo test environment. We verify DB storage works. - dbValue, err := testStore.GetConfig(ctx, syncbranch.ConfigKey) - if err != nil { - t.Fatalf("failed to read %s from store: %v", syncbranch.ConfigKey, err) - } - if dbValue != "beads-metadata" { - t.Errorf("store.GetConfig(%s) = %q, want %q", syncbranch.ConfigKey, dbValue, "beads-metadata") - } - t.Logf("✓ sync.branch config key correctly stored: %s", dbValue) - - // Key assertion: The sync-branch detection mechanism works - // When sync.branch is configured, doPullFirstSync gates on it (sync.go:181-189) - // and the daemon handles sync-branch commits (daemon_sync_branch.go) -} - -// TestExternalBeadsDirWithPullFirst verifies that external BEADS_DIR mode -// is correctly detected and the commit/pull functions work. -// This addresses Steve's review concern about external beads dir regression. -func TestExternalBeadsDirWithPullFirst(t *testing.T) { - ctx := context.Background() - - // Setup: Create main project repo - mainDir, cleanupMain := setupGitRepo(t) - defer cleanupMain() - - // Setup: Create separate external beads repo - // Resolve symlinks to avoid macOS /var -> /private/var issues - externalDir, err := filepath.EvalSymlinks(t.TempDir()) - if err != nil { - t.Fatalf("eval symlinks failed: %v", err) - } - - // Initialize external repo - if err := exec.Command("git", "-C", externalDir, "init", "--initial-branch=main").Run(); err != nil { - t.Fatalf("git init (external) failed: %v", err) - } - _ = exec.Command("git", "-C", externalDir, "config", "user.email", "test@test.com").Run() - _ = exec.Command("git", "-C", externalDir, "config", "user.name", "Test User").Run() - - // Create initial commit in external repo - if err := os.WriteFile(filepath.Join(externalDir, "README.md"), []byte("External beads repo"), 0644); err != nil { - t.Fatalf("write README failed: %v", err) - } - _ = exec.Command("git", "-C", externalDir, "add", ".").Run() - if err := exec.Command("git", "-C", externalDir, "commit", "-m", "initial").Run(); err != nil { - t.Fatalf("external initial commit failed: %v", err) - } - - // Create .beads directory in external repo - externalBeadsDir := filepath.Join(externalDir, ".beads") - if err := os.MkdirAll(externalBeadsDir, 0755); err != nil { - t.Fatalf("mkdir external beads failed: %v", err) - } - - // Create issues.jsonl in external beads - jsonlPath := filepath.Join(externalBeadsDir, "issues.jsonl") - issueContent := `{"id":"ext-1","title":"External Issue","status":"open","issue_type":"task","priority":2,"created_at":"2025-01-01T00:00:00Z","updated_at":"2025-01-01T00:00:00Z"}` - if err := os.WriteFile(jsonlPath, []byte(issueContent+"\n"), 0644); err != nil { - t.Fatalf("write external JSONL failed: %v", err) - } - - // Commit initial beads files - _ = exec.Command("git", "-C", externalDir, "add", ".beads").Run() - _ = exec.Command("git", "-C", externalDir, "commit", "-m", "add beads").Run() - - // Change back to main repo (simulating user's project) - if err := os.Chdir(mainDir); err != nil { - t.Fatalf("chdir to main failed: %v", err) - } - - // Test 1: isExternalBeadsDir should detect external repo - if !isExternalBeadsDir(ctx, externalBeadsDir) { - t.Error("isExternalBeadsDir should return true for external beads dir") - } - t.Log("✓ External beads dir correctly detected") - - // Test 2: Verify the external beads functions exist and are callable - // The actual commit test requires more complex setup due to path resolution - // The key verification is that detection works (Test 1) - // and the functions are present (verified by compilation) - - // Test 3: pullFromExternalBeadsRepo should not error (no remote) - // This tests the function handles no-remote gracefully - err = pullFromExternalBeadsRepo(ctx, externalBeadsDir) - if err != nil { - t.Errorf("pullFromExternalBeadsRepo should handle no-remote: %v", err) - } - t.Log("✓ Pull from external beads repo handled no-remote correctly") - - // Test 4: Verify getRepoRootFromPath works for external dir - repoRoot, err := getRepoRootFromPath(ctx, externalBeadsDir) - if err != nil { - t.Fatalf("getRepoRootFromPath failed: %v", err) - } - // Should return the external repo root - resolvedExternal, _ := filepath.EvalSymlinks(externalDir) - if repoRoot != resolvedExternal { - t.Errorf("getRepoRootFromPath = %q, want %q", repoRoot, resolvedExternal) - } - t.Logf("✓ getRepoRootFromPath correctly identifies external repo: %s", repoRoot) -} - -// TestMergeIssuesWithBaseState verifies the 3-way merge algorithm -// that underpins pull-first sync works correctly with base state. -// This is the core algorithm that prevents data loss (#911). -func TestMergeIssuesWithBaseState(t *testing.T) { - t.Parallel() - - baseTime := time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC) - localTime := time.Date(2025, 1, 2, 0, 0, 0, 0, time.UTC) - remoteTime := time.Date(2025, 1, 3, 0, 0, 0, 0, time.UTC) - - tests := []struct { - name string - base []*beads.Issue - local []*beads.Issue - remote []*beads.Issue - wantCount int - wantConflicts int - wantStrategy map[string]string - wantTitles map[string]string // id -> expected title - }{ - { - name: "only remote changed", - base: []*beads.Issue{ - {ID: "bd-1", Title: "Original", UpdatedAt: baseTime}, - }, - local: []*beads.Issue{ - {ID: "bd-1", Title: "Original", UpdatedAt: baseTime}, - }, - remote: []*beads.Issue{ - {ID: "bd-1", Title: "Remote Edit", UpdatedAt: remoteTime}, - }, - wantCount: 1, - wantConflicts: 0, - wantStrategy: map[string]string{"bd-1": StrategyRemote}, - wantTitles: map[string]string{"bd-1": "Remote Edit"}, - }, - { - name: "only local changed", - base: []*beads.Issue{ - {ID: "bd-1", Title: "Original", UpdatedAt: baseTime}, - }, - local: []*beads.Issue{ - {ID: "bd-1", Title: "Local Edit", UpdatedAt: localTime}, - }, - remote: []*beads.Issue{ - {ID: "bd-1", Title: "Original", UpdatedAt: baseTime}, - }, - wantCount: 1, - wantConflicts: 0, - wantStrategy: map[string]string{"bd-1": StrategyLocal}, - wantTitles: map[string]string{"bd-1": "Local Edit"}, - }, - { - name: "true conflict - remote wins LWW", - base: []*beads.Issue{ - {ID: "bd-1", Title: "Original", UpdatedAt: baseTime}, - }, - local: []*beads.Issue{ - {ID: "bd-1", Title: "Local Edit", UpdatedAt: localTime}, - }, - remote: []*beads.Issue{ - {ID: "bd-1", Title: "Remote Edit", UpdatedAt: remoteTime}, - }, - wantCount: 1, - wantConflicts: 1, - wantStrategy: map[string]string{"bd-1": StrategyMerged}, - wantTitles: map[string]string{"bd-1": "Remote Edit"}, // Remote wins (later timestamp) - }, - { - name: "new issue from remote", - base: []*beads.Issue{}, - local: []*beads.Issue{}, - remote: []*beads.Issue{ - {ID: "bd-1", Title: "New Remote Issue", UpdatedAt: remoteTime}, - }, - wantCount: 1, - wantConflicts: 0, - wantStrategy: map[string]string{"bd-1": StrategyRemote}, - wantTitles: map[string]string{"bd-1": "New Remote Issue"}, - }, - { - name: "new issue from local", - base: []*beads.Issue{}, - local: []*beads.Issue{ - {ID: "bd-1", Title: "New Local Issue", UpdatedAt: localTime}, - }, - remote: []*beads.Issue{}, - wantCount: 1, - wantConflicts: 0, - wantStrategy: map[string]string{"bd-1": StrategyLocal}, - wantTitles: map[string]string{"bd-1": "New Local Issue"}, - }, - { - name: "both made identical change", - base: []*beads.Issue{ - {ID: "bd-1", Title: "Original", UpdatedAt: baseTime}, - }, - local: []*beads.Issue{ - {ID: "bd-1", Title: "Same Edit", UpdatedAt: localTime}, - }, - remote: []*beads.Issue{ - {ID: "bd-1", Title: "Same Edit", UpdatedAt: localTime}, - }, - wantCount: 1, - wantConflicts: 0, - wantStrategy: map[string]string{"bd-1": StrategySame}, - wantTitles: map[string]string{"bd-1": "Same Edit"}, - }, - } - - for _, tt := range tests { - tt := tt - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - result := MergeIssues(tt.base, tt.local, tt.remote) - - if len(result.Merged) != tt.wantCount { - t.Errorf("got %d merged issues, want %d", len(result.Merged), tt.wantCount) - } - - if result.Conflicts != tt.wantConflicts { - t.Errorf("got %d conflicts, want %d", result.Conflicts, tt.wantConflicts) - } - - for id, wantStrategy := range tt.wantStrategy { - if result.Strategy[id] != wantStrategy { - t.Errorf("strategy[%s] = %q, want %q", id, result.Strategy[id], wantStrategy) - } - } - - for _, issue := range result.Merged { - if wantTitle, ok := tt.wantTitles[issue.ID]; ok { - if issue.Title != wantTitle { - t.Errorf("title[%s] = %q, want %q", issue.ID, issue.Title, wantTitle) - } - } - } - }) - } -} - -// TestUpgradeFromOldSync verifies that existing projects safely upgrade to pull-first. -// When sync_base.jsonl doesn't exist (first sync after upgrade), the merge should: -// 1. Keep issues that only exist locally -// 2. Keep issues that only exist remotely -// 3. Merge issues that exist in both (using LWW for scalars, union for sets) -// This is critical for production safety. -func TestUpgradeFromOldSync(t *testing.T) { - t.Parallel() - - localTime := time.Date(2025, 1, 2, 0, 0, 0, 0, time.UTC) - remoteTime := time.Date(2025, 1, 3, 0, 0, 0, 0, time.UTC) - - // Simulate upgrade scenario: base=nil (no sync_base.jsonl) - // Local has 2 issues, remote has 2 issues (1 overlap) - local := []*beads.Issue{ - {ID: "bd-1", Title: "Shared Issue Local", Labels: []string{"local-label"}, UpdatedAt: localTime}, - {ID: "bd-2", Title: "Local Only Issue", UpdatedAt: localTime}, - } - remote := []*beads.Issue{ - {ID: "bd-1", Title: "Shared Issue Remote", Labels: []string{"remote-label"}, UpdatedAt: remoteTime}, - {ID: "bd-3", Title: "Remote Only Issue", UpdatedAt: remoteTime}, - } - - // Key: base is nil (simulating upgrade from old sync) - result := MergeIssues(nil, local, remote) - - // Should have 3 issues total - if len(result.Merged) != 3 { - t.Fatalf("expected 3 merged issues, got %d", len(result.Merged)) - } - - // Build map for easier assertions - byID := make(map[string]*beads.Issue) - for _, issue := range result.Merged { - byID[issue.ID] = issue - } - - // bd-1: Shared issue should be merged (remote wins LWW, labels union) - if issue, ok := byID["bd-1"]; ok { - // Remote wins LWW (later timestamp) - if issue.Title != "Shared Issue Remote" { - t.Errorf("bd-1 title = %q, want 'Shared Issue Remote' (LWW)", issue.Title) - } - // Labels should be union - if len(issue.Labels) != 2 { - t.Errorf("bd-1 labels = %v, want union of local and remote labels", issue.Labels) - } - if result.Strategy["bd-1"] != StrategyMerged { - t.Errorf("bd-1 strategy = %q, want %q", result.Strategy["bd-1"], StrategyMerged) - } - } else { - t.Error("bd-1 should exist in merged result") - } - - // bd-2: Local only should be kept - if issue, ok := byID["bd-2"]; ok { - if issue.Title != "Local Only Issue" { - t.Errorf("bd-2 title = %q, want 'Local Only Issue'", issue.Title) - } - if result.Strategy["bd-2"] != StrategyLocal { - t.Errorf("bd-2 strategy = %q, want %q", result.Strategy["bd-2"], StrategyLocal) - } - } else { - t.Error("bd-2 should exist in merged result (local only)") - } - - // bd-3: Remote only should be kept - if issue, ok := byID["bd-3"]; ok { - if issue.Title != "Remote Only Issue" { - t.Errorf("bd-3 title = %q, want 'Remote Only Issue'", issue.Title) - } - if result.Strategy["bd-3"] != StrategyRemote { - t.Errorf("bd-3 strategy = %q, want %q", result.Strategy["bd-3"], StrategyRemote) - } - } else { - t.Error("bd-3 should exist in merged result (remote only)") - } - - t.Log("✓ Upgrade from old sync safely merges all issues") -} - -// TestLabelUnionMerge verifies that labels use union merge (no data loss). -// This is the field-level resolution Steve asked about. -func TestLabelUnionMerge(t *testing.T) { - t.Parallel() - - baseTime := time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC) - localTime := time.Date(2025, 1, 2, 0, 0, 0, 0, time.UTC) - remoteTime := time.Date(2025, 1, 3, 0, 0, 0, 0, time.UTC) - - base := []*beads.Issue{ - {ID: "bd-1", Title: "Issue", Labels: []string{"bug"}, UpdatedAt: baseTime}, - } - local := []*beads.Issue{ - {ID: "bd-1", Title: "Issue", Labels: []string{"bug", "local-label"}, UpdatedAt: localTime}, - } - remote := []*beads.Issue{ - {ID: "bd-1", Title: "Issue", Labels: []string{"bug", "remote-label"}, UpdatedAt: remoteTime}, - } - - result := MergeIssues(base, local, remote) - - if len(result.Merged) != 1 { - t.Fatalf("expected 1 merged issue, got %d", len(result.Merged)) - } - - // Labels should be union of both: bug, local-label, remote-label - labels := result.Merged[0].Labels - expectedLabels := map[string]bool{"bug": true, "local-label": true, "remote-label": true} - - if len(labels) != 3 { - t.Errorf("expected 3 labels, got %d: %v", len(labels), labels) - } - - for _, label := range labels { - if !expectedLabels[label] { - t.Errorf("unexpected label: %s", label) - } - } - - t.Logf("✓ Labels correctly union-merged: %v", labels) -} - -// setupBareRemoteWithClones creates a bare repo (simulating GitHub) and two clones -// for multi-machine E2E testing. Each clone has its own .beads directory for isolation. -// -// Returns: -// - remoteDir: path to bare repo (the "remote") -// - machineA: path to first clone -// - machineB: path to second clone -// - cleanup: function to call in defer -func setupBareRemoteWithClones(t *testing.T) (remoteDir, machineA, machineB string, cleanup func()) { - t.Helper() - - // Create bare repo (acts as "GitHub") - remoteDir = t.TempDir() - // Resolve symlinks to avoid macOS /var -> /private/var issues - remoteDir, _ = filepath.EvalSymlinks(remoteDir) - cmd := exec.Command("git", "init", "--bare", "-b", "main") - cmd.Dir = remoteDir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to init bare repo: %v", err) - } - - // Clone for Machine A - machineA = t.TempDir() - machineA, _ = filepath.EvalSymlinks(machineA) - if err := exec.Command("git", "clone", remoteDir, machineA).Run(); err != nil { - t.Fatalf("failed to clone for machineA: %v", err) - } - // Configure git user in Machine A - _ = exec.Command("git", "-C", machineA, "config", "user.email", "machineA@test.com").Run() - _ = exec.Command("git", "-C", machineA, "config", "user.name", "Machine A").Run() - - // Clone for Machine B - machineB = t.TempDir() - machineB, _ = filepath.EvalSymlinks(machineB) - if err := exec.Command("git", "clone", remoteDir, machineB).Run(); err != nil { - t.Fatalf("failed to clone for machineB: %v", err) - } - // Configure git user in Machine B - _ = exec.Command("git", "-C", machineB, "config", "user.email", "machineB@test.com").Run() - _ = exec.Command("git", "-C", machineB, "config", "user.name", "Machine B").Run() - - // Initial commit from Machine A (bare repos need at least one commit) - readmePath := filepath.Join(machineA, "README.md") - if err := os.WriteFile(readmePath, []byte("# Test Repo\n"), 0644); err != nil { - t.Fatalf("failed to write README: %v", err) - } - _ = exec.Command("git", "-C", machineA, "add", ".").Run() - if err := exec.Command("git", "-C", machineA, "commit", "-m", "initial").Run(); err != nil { - t.Fatalf("failed to create initial commit: %v", err) - } - if err := exec.Command("git", "-C", machineA, "push", "-u", "origin", "main").Run(); err != nil { - t.Fatalf("failed to push initial commit: %v", err) - } - - // Machine B fetches and checks out main - _ = exec.Command("git", "-C", machineB, "fetch", "origin").Run() - _ = exec.Command("git", "-C", machineB, "checkout", "main").Run() - - cleanup = func() { - git.ResetCaches() // Prevent cache pollution between tests - } - - return remoteDir, machineA, machineB, cleanup -} - -// withBeadsDir runs a function with BEADS_DIR set to the specified directory's .beads subdirectory. -// This provides database isolation for multi-machine tests. -func withBeadsDir(t *testing.T, dir string, fn func()) { - t.Helper() - - origBeadsDir := os.Getenv("BEADS_DIR") - beadsDir := filepath.Join(dir, ".beads") - - // Create .beads directory if it doesn't exist - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("failed to create .beads dir: %v", err) - } - - os.Setenv("BEADS_DIR", beadsDir) - defer func() { - if origBeadsDir != "" { - os.Setenv("BEADS_DIR", origBeadsDir) - } else { - os.Unsetenv("BEADS_DIR") - } - }() - - fn() -} - -// TestSyncBranchE2E tests the full sync-branch flow with concurrent changes from -// two machines using a real bare repo. This is an end-to-end regression test for PR#918. -// -// Flow: -// 1. Machine A creates bd-1, commits to sync branch, pushes to bare remote -// 2. Machine B creates bd-2, commits to sync branch, pushes to bare remote -// 3. Machine A pulls from sync branch - should merge both issues -// 4. Verify both issues present after merge -func TestSyncBranchE2E(t *testing.T) { - ctx := context.Background() - - // Setup: Create bare remote with two clones - _, machineA, machineB, cleanup := setupBareRemoteWithClones(t) - defer cleanup() - - syncBranch := "beads-sync" - - // Machine A: Create .beads directory and bd-1 - beadsDirA := filepath.Join(machineA, ".beads") - if err := os.MkdirAll(beadsDirA, 0755); err != nil { - t.Fatalf("failed to create .beads dir for A: %v", err) - } - jsonlPathA := filepath.Join(beadsDirA, "issues.jsonl") - issue1 := `{"id":"bd-1","title":"Issue from Machine A","status":"open","issue_type":"task","priority":2,"created_at":"2025-01-01T00:00:00Z","updated_at":"2025-01-01T00:00:00Z"}` - if err := os.WriteFile(jsonlPathA, []byte(issue1+"\n"), 0644); err != nil { - t.Fatalf("write JSONL failed for A: %v", err) - } - - // Machine A: Commit to sync branch using the worktree-based API (push=true) - withBeadsDir(t, machineA, func() { - commitResult, err := syncbranch.CommitToSyncBranch(ctx, machineA, syncBranch, jsonlPathA, true) - if err != nil { - t.Fatalf("CommitToSyncBranch failed for A: %v", err) - } - if !commitResult.Committed { - t.Fatal("expected commit to succeed for Machine A's issue") - } - t.Log("Machine A committed and pushed bd-1 to sync branch") - }) - - // Machine B: Create .beads directory and bd-2 - beadsDirB := filepath.Join(machineB, ".beads") - if err := os.MkdirAll(beadsDirB, 0755); err != nil { - t.Fatalf("failed to create .beads dir for B: %v", err) - } - jsonlPathB := filepath.Join(beadsDirB, "issues.jsonl") - issue2 := `{"id":"bd-2","title":"Issue from Machine B","status":"open","issue_type":"task","priority":2,"created_at":"2025-01-02T00:00:00Z","updated_at":"2025-01-02T00:00:00Z"}` - if err := os.WriteFile(jsonlPathB, []byte(issue2+"\n"), 0644); err != nil { - t.Fatalf("write JSONL failed for B: %v", err) - } - - // Machine B: Pull first to get A's changes, then commit and push - withBeadsDir(t, machineB, func() { - // Pull from remote first (gets Machine A's bd-1) - pullResult, err := syncbranch.PullFromSyncBranch(ctx, machineB, syncBranch, jsonlPathB, false) - if err != nil { - t.Logf("Initial pull for B returned error (may be expected): %v", err) - } - if pullResult != nil && pullResult.Pulled { - t.Log("Machine B pulled existing sync branch content") - } - - // Re-read and append bd-2 to maintain bd-1 from pull - existingContent, _ := os.ReadFile(jsonlPathB) - if !strings.Contains(string(existingContent), "bd-2") { - // Append bd-2 if not already present - if len(existingContent) > 0 && !strings.HasSuffix(string(existingContent), "\n") { - existingContent = append(existingContent, '\n') - } - newContent := string(existingContent) + issue2 + "\n" - if err := os.WriteFile(jsonlPathB, []byte(newContent), 0644); err != nil { - t.Fatalf("failed to append bd-2: %v", err) - } - } - - // Commit and push bd-2 - commitResult, err := syncbranch.CommitToSyncBranch(ctx, machineB, syncBranch, jsonlPathB, true) - if err != nil { - t.Fatalf("CommitToSyncBranch failed for B: %v", err) - } - if !commitResult.Committed { - t.Log("Machine B had no new changes to commit (bd-2 may already be in sync)") - } else { - t.Log("Machine B committed and pushed bd-2 to sync branch") - } - }) - - // Machine A: Pull from sync branch - should merge both issues - withBeadsDir(t, machineA, func() { - pullResult, err := syncbranch.PullFromSyncBranch(ctx, machineA, syncBranch, jsonlPathA, false) - if err != nil { - t.Logf("PullFromSyncBranch for A returned error (may be expected): %v", err) - } - if pullResult != nil { - t.Logf("Pull result for A: Pulled=%v, Merged=%v, FastForwarded=%v", - pullResult.Pulled, pullResult.Merged, pullResult.FastForwarded) - } - }) - - // Verify: Both issues should be present in Machine A's JSONL after merge - content, err := os.ReadFile(jsonlPathA) - if err != nil { - t.Fatalf("failed to read merged JSONL: %v", err) - } - - contentStr := string(content) - hasIssue1 := strings.Contains(contentStr, "bd-1") || strings.Contains(contentStr, "Machine A") - hasIssue2 := strings.Contains(contentStr, "bd-2") || strings.Contains(contentStr, "Machine B") - - if hasIssue1 { - t.Log("Issue bd-1 from Machine A preserved") - } else { - t.Error("FAIL: bd-1 from Machine A missing after merge") - } - - if hasIssue2 { - t.Log("Issue bd-2 from Machine B merged") - } else { - t.Error("FAIL: bd-2 from Machine B missing after merge") - } - - if hasIssue1 && hasIssue2 { - t.Log("Sync-branch E2E test PASSED: both issues present after merge") - } -} - -// TestExportOnlySync tests the --no-pull mode (export-only sync). -// This mode skips pulling from remote and only exports local changes. -// -// Use case: "I just want to push my local changes, don't merge anything" -// -// Flow: -// 1. Create local issue in database -// 2. Run export-only sync (doExportOnlySync) -// 3. Verify issue is exported to JSONL -// 4. Verify changes are committed -func TestExportOnlySync(t *testing.T) { - ctx := context.Background() - tmpDir, cleanup := setupGitRepo(t) - defer cleanup() - - beadsDir := filepath.Join(tmpDir, ".beads") - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - - // Remove pre-existing issues.jsonl from setupGitRepo (we want a clean slate) - _ = os.Remove(jsonlPath) - - // Setup: Create .beads directory - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("failed to create .beads dir: %v", err) - } - - // Create a database with a test issue - dbPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - - // Set issue prefix (required for export) - if err := testStore.SetConfig(ctx, "issue_prefix", "export-test"); err != nil { - t.Fatalf("failed to set issue_prefix: %v", err) - } - - // Create a test issue in the database - testIssue := &types.Issue{ - ID: "export-test-1", - Title: "Export Only Test Issue", - Status: "open", - IssueType: "task", - Priority: 2, - CreatedAt: time.Now(), - UpdatedAt: time.Now(), - } - if err := testStore.CreateIssue(ctx, testIssue, "test"); err != nil { - t.Fatalf("failed to create test issue: %v", err) - } - testStore.Close() - t.Log("✓ Created test issue in database") - - // Initialize the global store for doExportOnlySync - // This simulates what `bd sync --no-pull` does - store, err = dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to open store: %v", err) - } - defer func() { - store.Close() - store = nil - }() - - // Run export-only sync (--no-pull mode) - // noPush=true to avoid needing a real remote in tests - if err := doExportOnlySync(ctx, jsonlPath, true, "bd sync: export test"); err != nil { - t.Fatalf("doExportOnlySync failed: %v", err) - } - t.Log("✓ Export-only sync completed") - - // Verify: JSONL file should exist with our issue - content, err := os.ReadFile(jsonlPath) - if err != nil { - t.Fatalf("failed to read JSONL: %v", err) - } - - contentStr := string(content) - if !strings.Contains(contentStr, "export-test-1") { - t.Errorf("JSONL should contain issue ID 'export-test-1', got: %s", contentStr) - } - if !strings.Contains(contentStr, "Export Only Test Issue") { - t.Errorf("JSONL should contain issue title, got: %s", contentStr) - } - t.Log("✓ Issue correctly exported to JSONL") - - // Verify: Changes should be committed - output, err := exec.Command("git", "log", "-1", "--pretty=format:%s").Output() - if err != nil { - t.Fatalf("git log failed: %v", err) - } - commitMsg := string(output) - if !strings.Contains(commitMsg, "bd sync") { - t.Errorf("expected commit message to contain 'bd sync', got: %s", commitMsg) - } - t.Log("✓ Changes committed with correct message") - - // Verify: issues.jsonl should be tracked and committed (no modifications) - // Note: Database files (.db, .db-wal, .db-shm) and .sync.lock remain untracked - // as expected - only JSONL is committed to git - status, err := exec.Command("git", "status", "--porcelain", jsonlPath).Output() - if err != nil { - t.Fatalf("git status failed: %v", err) - } - if len(status) > 0 { - t.Errorf("expected issues.jsonl to be committed, got: %s", status) - } - t.Log("✓ issues.jsonl is committed after export-only sync") -} - -// TestSync_FailsWhenOnSyncBranch verifies that bd sync fails gracefully -// when the current branch matches the configured sync branch. -// This is the runtime guard for GH#1166 - prevents bd sync from attempting -// to create a worktree for a branch that's already checked out. -// -// The issue: If sync.branch = "main" and user is on "main", bd sync would -// try to create a worktree for "main" which fails because it's already checked out. -// Worse, some code paths could commit all staged files instead of just .beads/. -func TestSync_FailsWhenOnSyncBranch(t *testing.T) { - ctx := context.Background() - tmpDir, cleanup := setupGitRepo(t) - defer cleanup() - - // Get current branch name (should be "main" from setupGitRepo) - currentBranch, err := syncbranch.GetCurrentBranch(ctx) - if err != nil { - t.Fatalf("failed to get current branch: %v", err) - } - t.Logf("Current branch: %s", currentBranch) - - // Test 1: IsSyncBranchSameAsCurrent returns true when branch matches - if !syncbranch.IsSyncBranchSameAsCurrent(ctx, currentBranch) { - t.Error("IsSyncBranchSameAsCurrent should return true when sync branch matches current branch") - } - t.Log("✓ IsSyncBranchSameAsCurrent correctly detects same-branch condition") - - // Test 2: IsSyncBranchSameAsCurrent returns false for different branch - if syncbranch.IsSyncBranchSameAsCurrent(ctx, "beads-sync") { - t.Error("IsSyncBranchSameAsCurrent should return false for different branch name") - } - t.Log("✓ IsSyncBranchSameAsCurrent correctly allows different branch names") - - // Test 3: Setup sync.branch config to match current branch (the problematic state) - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("failed to create .beads dir: %v", err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: dbPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - defer testStore.Close() - - // Configure sync.branch to match current branch (this is the bug condition) - if err := testStore.SetConfig(ctx, "sync.branch", currentBranch); err != nil { - t.Fatalf("failed to set sync.branch: %v", err) - } - t.Logf("✓ Configured sync.branch = %s (matches current branch)", currentBranch) - - // Verify the config is stored correctly - syncBranchValue, err := testStore.GetConfig(ctx, "sync.branch") - if err != nil { - t.Fatalf("failed to get sync.branch config: %v", err) - } - if syncBranchValue != currentBranch { - t.Errorf("sync.branch config = %q, want %q", syncBranchValue, currentBranch) - } - - // Test 4: The runtime guard logic (same as in sync.go) - // This simulates what happens in the sync command - syncBranchName := syncBranchValue - hasSyncBranchConfig := syncBranchName != "" - - if hasSyncBranchConfig { - if syncbranch.IsSyncBranchSameAsCurrent(ctx, syncBranchName) { - // This is the expected behavior - we caught the misconfiguration - t.Log("✓ Runtime guard correctly detected sync-branch = current-branch condition") - } else { - t.Error("FAIL: Runtime guard did not detect sync-branch = current-branch condition") - } - } else { - t.Error("FAIL: sync.branch config should be set") - } - - t.Log("✓ TestSync_FailsWhenOnSyncBranch PASSED") -} diff --git a/cmd/bd/sync_state.go b/cmd/bd/sync_state.go deleted file mode 100644 index 861c9587a..000000000 --- a/cmd/bd/sync_state.go +++ /dev/null @@ -1,178 +0,0 @@ -package main - -import ( - "encoding/json" - "os" - "path/filepath" - "sync" - "time" -) - -// SyncState tracks sync health for backoff and user hints. -// Stored in .beads/sync-state.json (gitignored, local-only). -type SyncState struct { - LastFailure time.Time `json:"last_failure,omitempty"` - FailureCount int `json:"failure_count"` - BackoffUntil time.Time `json:"backoff_until,omitempty"` - NeedsManualSync bool `json:"needs_manual_sync"` - FailureReason string `json:"failure_reason,omitempty"` -} - -const ( - syncStateFile = "sync-state.json" - // Backoff schedule: 30s, 1m, 2m, 5m, 10m, 30m (cap) - maxBackoffDuration = 30 * time.Minute - // Clear stale state after 24 hours - staleStateThreshold = 24 * time.Hour -) - -var ( - // backoffSchedule defines the exponential backoff durations - backoffSchedule = []time.Duration{ - 30 * time.Second, - 1 * time.Minute, - 2 * time.Minute, - 5 * time.Minute, - 10 * time.Minute, - 30 * time.Minute, - } - // syncStateMu protects concurrent access to sync state file - syncStateMu sync.Mutex -) - -// LoadSyncState loads the sync state from .beads/sync-state.json. -// Returns empty state if file doesn't exist or is stale. -func LoadSyncState(beadsDir string) SyncState { - syncStateMu.Lock() - defer syncStateMu.Unlock() - return loadSyncStateUnlocked(beadsDir) -} - -// loadSyncStateUnlocked loads sync state without acquiring lock. -// Caller must hold syncStateMu. -func loadSyncStateUnlocked(beadsDir string) SyncState { - statePath := filepath.Join(beadsDir, syncStateFile) - data, err := os.ReadFile(statePath) // #nosec G304 - path constructed from beadsDir - if err != nil { - return SyncState{} - } - - var state SyncState - if err := json.Unmarshal(data, &state); err != nil { - return SyncState{} - } - - // Clear stale state (older than 24h with no recent failures) - if !state.LastFailure.IsZero() && time.Since(state.LastFailure) > staleStateThreshold { - _ = os.Remove(statePath) - return SyncState{} - } - - return state -} - -// SaveSyncState saves the sync state to .beads/sync-state.json. -func SaveSyncState(beadsDir string, state SyncState) error { - syncStateMu.Lock() - defer syncStateMu.Unlock() - return saveSyncStateUnlocked(beadsDir, state) -} - -// saveSyncStateUnlocked saves sync state without acquiring lock. -// Caller must hold syncStateMu. -func saveSyncStateUnlocked(beadsDir string, state SyncState) error { - statePath := filepath.Join(beadsDir, syncStateFile) - - // If state is empty/reset, remove the file - if state.FailureCount == 0 && !state.NeedsManualSync { - _ = os.Remove(statePath) - return nil - } - - data, err := json.MarshalIndent(state, "", " ") - if err != nil { - return err - } - - return os.WriteFile(statePath, data, 0600) -} - -// ClearSyncState removes the sync state file. -func ClearSyncState(beadsDir string) error { - syncStateMu.Lock() - defer syncStateMu.Unlock() - - statePath := filepath.Join(beadsDir, syncStateFile) - err := os.Remove(statePath) - if os.IsNotExist(err) { - return nil - } - return err -} - -// RecordSyncFailure updates the sync state after a failure. -// Returns the duration until next retry. -func RecordSyncFailure(beadsDir string, reason string) time.Duration { - syncStateMu.Lock() - defer syncStateMu.Unlock() - - state := loadSyncStateUnlocked(beadsDir) - - state.LastFailure = time.Now() - state.FailureCount++ - state.FailureReason = reason - - // Calculate backoff duration - backoffIndex := state.FailureCount - 1 - if backoffIndex >= len(backoffSchedule) { - backoffIndex = len(backoffSchedule) - 1 - } - backoff := backoffSchedule[backoffIndex] - - state.BackoffUntil = time.Now().Add(backoff) - - // Mark as needing manual sync after 3 failures (likely a conflict) - if state.FailureCount >= 3 { - state.NeedsManualSync = true - } - - _ = saveSyncStateUnlocked(beadsDir, state) // Best effort: state persistence is advisory for backoff logic - return backoff -} - -// RecordSyncSuccess clears the sync state after a successful sync. -func RecordSyncSuccess(beadsDir string) { - _ = ClearSyncState(beadsDir) // Best effort: stale state is harmless -} - -// ShouldSkipSync returns true if we're still in the backoff period. -func ShouldSkipSync(beadsDir string) bool { - state := LoadSyncState(beadsDir) - if state.BackoffUntil.IsZero() { - return false - } - return time.Now().Before(state.BackoffUntil) -} - -// ResetBackoffOnDaemonStart resets backoff counters when daemon starts, -// but preserves NeedsManualSync flag so hints still show. -func ResetBackoffOnDaemonStart(beadsDir string) { - syncStateMu.Lock() - defer syncStateMu.Unlock() - - state := loadSyncStateUnlocked(beadsDir) - - if state.FailureCount == 0 && !state.NeedsManualSync { - return - } - - needsManual := state.NeedsManualSync - reason := state.FailureReason - - state = SyncState{ - NeedsManualSync: needsManual, - FailureReason: reason, - } - - _ = saveSyncStateUnlocked(beadsDir, state) -} diff --git a/cmd/bd/sync_status.go b/cmd/bd/sync_status.go deleted file mode 100644 index 9a47938ce..000000000 --- a/cmd/bd/sync_status.go +++ /dev/null @@ -1,143 +0,0 @@ -package main - -import ( - "context" - "fmt" - "os" - "path/filepath" - "strings" - "time" - - "github.com/steveyegge/beads/internal/beads" - "github.com/steveyegge/beads/internal/config" - "github.com/steveyegge/beads/internal/syncbranch" -) - -// showSyncStateStatus shows the current sync state per the spec. -// Output format: -// -// Sync mode: git-portable -// Last export: 2026-01-16 10:30:00 (commit abc123) -// Pending changes: 3 issues modified since last export -// Import branch: none -// Conflicts: none -func showSyncStateStatus(ctx context.Context, jsonlPath string) error { - if err := ensureStoreActive(); err != nil { - return fmt.Errorf("failed to initialize store: %w", err) - } - - beadsDir := filepath.Dir(jsonlPath) - - // Sync mode (from config) - syncCfg := config.GetSyncConfig() - fmt.Printf("Sync mode: %s (%s)\n", syncCfg.Mode, SyncModeDescription(string(syncCfg.Mode))) - fmt.Printf(" Export on: %s, Import on: %s\n", syncCfg.ExportOn, syncCfg.ImportOn) - - // Conflict strategy - conflictCfg := config.GetConflictConfig() - fmt.Printf("Conflict strategy: %s\n", conflictCfg.Strategy) - - // Federation config (if set) - fedCfg := config.GetFederationConfig() - if fedCfg.Remote != "" { - fmt.Printf("Federation remote: %s\n", fedCfg.Remote) - if fedCfg.Sovereignty != "" { - fmt.Printf(" Sovereignty: %s\n", fedCfg.Sovereignty) - } - } - - // Last export time - lastExport, err := store.GetMetadata(ctx, "last_import_time") - if err != nil || lastExport == "" { - fmt.Println("Last export: never") - } else { - // Try to parse and format nicely - t, err := time.Parse(time.RFC3339Nano, lastExport) - if err != nil { - fmt.Printf("Last export: %s\n", lastExport) - } else { - // Try to get the last commit hash for the JSONL file - commitHash := getLastJSONLCommitHash(ctx, jsonlPath) - if commitHash != "" { - fmt.Printf("Last export: %s (commit %s)\n", t.Format("2006-01-02 15:04:05"), commitHash[:7]) - } else { - fmt.Printf("Last export: %s\n", t.Format("2006-01-02 15:04:05")) - } - } - } - - // Dirty tracking removed (woho.4) — pending changes not tracked - fmt.Println("Pending changes: not tracked (dirty tracking removed)") - - // Import branch (sync branch status) - syncBranch, _ := syncbranch.Get(ctx, store) - if syncBranch == "" { - fmt.Println("Import branch: none") - } else { - fmt.Printf("Import branch: %s\n", syncBranch) - } - - // Conflicts - check for sync conflict state file - syncConflictPath := filepath.Join(beadsDir, "sync_conflicts.json") - if _, err := os.Stat(syncConflictPath); err == nil { - conflictState, err := LoadSyncConflictState(beadsDir) - if err != nil { - fmt.Println("Conflicts: unknown (error reading sync state)") - } else if len(conflictState.Conflicts) > 0 { - fmt.Printf("Conflicts: %d unresolved\n", len(conflictState.Conflicts)) - for _, c := range conflictState.Conflicts { - fmt.Printf(" - %s: %s\n", c.IssueID, c.Reason) - } - } else { - fmt.Println("Conflicts: none") - } - } else { - fmt.Println("Conflicts: none") - } - - return nil -} - -// getLastJSONLCommitHash returns the short commit hash of the last commit -// that touched the JSONL file, or empty string if unknown. -func getLastJSONLCommitHash(ctx context.Context, jsonlPath string) string { - rc, err := beads.GetRepoContext() - if err != nil { - return "" - } - - cmd := rc.GitCmd(ctx, "log", "-1", "--format=%h", "--", jsonlPath) - output, err := cmd.Output() - if err != nil { - return "" - } - - return strings.TrimSpace(string(output)) -} - -// staleSyncLockAge is the maximum age of a sync lock file before it's considered stale. -// Sync operations should complete well within this window, even for large repos. -const staleSyncLockAge = 1 * time.Hour - -// cleanStaleSyncLock checks if the sync lock file is stale and removes it. -// Returns true if a stale lock was cleaned up. -// On Unix, flock is automatically released when a process exits, so this is a safety -// net for edge cases (NFS mounts, hung processes, container restarts). -func cleanStaleSyncLock(lockPath string) bool { - info, err := os.Stat(lockPath) - if err != nil { - return false - } - - age := time.Since(info.ModTime()) - if age <= staleSyncLockAge { - return false - } - - fmt.Fprintf(os.Stderr, "Warning: removing stale sync lock (age: %s)\n", age.Round(time.Second)) - if err := os.Remove(lockPath); err != nil { - fmt.Fprintf(os.Stderr, "Warning: failed to remove stale sync lock: %v\n", err) - return false - } - return true -} diff --git a/cmd/bd/sync_test.go b/cmd/bd/sync_test.go deleted file mode 100644 index b8e0a891e..000000000 --- a/cmd/bd/sync_test.go +++ /dev/null @@ -1,928 +0,0 @@ -//go:build cgo - -package main - -import ( - "context" - "os" - "os/exec" - "path/filepath" - "strings" - "testing" - "time" - - "github.com/gofrs/flock" - "github.com/steveyegge/beads/internal/storage/dolt" - "github.com/steveyegge/beads/internal/syncbranch" - "github.com/steveyegge/beads/internal/types" -) - -func TestIsGitRepo_InGitRepo(t *testing.T) { - // This test assumes we're running in the beads git repo - if !isGitRepo() { - t.Skip("not in a git repository") - } -} - -func TestIsGitRepo_NotInGitRepo(t *testing.T) { - tmpDir := t.TempDir() - t.Chdir(tmpDir) - - if isGitRepo() { - t.Error("expected false when not in git repo") - } -} - -func TestGitHasUpstream_NoUpstream(t *testing.T) { - _, cleanup := setupGitRepo(t) - defer cleanup() - - // Should not have upstream - if gitHasUpstream() { - t.Error("expected false when no upstream configured") - } -} - -func TestGitHasChanges_NoFile(t *testing.T) { - ctx := context.Background() - _, cleanup := setupGitRepo(t) - defer cleanup() - - // Check - should have no changes (test.txt was committed by setupGitRepo) - hasChanges, err := gitHasChanges(ctx, "test.txt") - if err != nil { - t.Fatalf("gitHasChanges() error = %v", err) - } - if hasChanges { - t.Error("expected no changes for committed file") - } -} - -func TestGitHasChanges_ModifiedFile(t *testing.T) { - ctx := context.Background() - tmpDir, cleanup := setupGitRepo(t) - defer cleanup() - - // Modify the file - testFile := filepath.Join(tmpDir, "test.txt") - os.WriteFile(testFile, []byte("modified"), 0644) - - // Check - should have changes - hasChanges, err := gitHasChanges(ctx, "test.txt") - if err != nil { - t.Fatalf("gitHasChanges() error = %v", err) - } - if !hasChanges { - t.Error("expected changes for modified file") - } -} - -func TestGitHasUnmergedPaths_CleanRepo(t *testing.T) { - _, cleanup := setupGitRepo(t) - defer cleanup() - - // Should not have unmerged paths - hasUnmerged, err := gitHasUnmergedPaths() - if err != nil { - t.Fatalf("gitHasUnmergedPaths() error = %v", err) - } - if hasUnmerged { - t.Error("expected no unmerged paths in clean repo") - } -} - -func TestGitCommit_Success(t *testing.T) { - ctx := context.Background() - _, cleanup := setupGitRepo(t) - defer cleanup() - - // Create a new file - testFile := "new.txt" - os.WriteFile(testFile, []byte("content"), 0644) - - // Commit the file - err := gitCommit(ctx, testFile, "test commit") - if err != nil { - t.Fatalf("gitCommit() error = %v", err) - } - - // Verify file is committed - hasChanges, err := gitHasChanges(ctx, testFile) - if err != nil { - t.Fatalf("gitHasChanges() error = %v", err) - } - if hasChanges { - t.Error("expected no changes after commit") - } -} - -func TestGitCommit_AutoMessage(t *testing.T) { - ctx := context.Background() - _, cleanup := setupGitRepo(t) - defer cleanup() - - // Create a new file - testFile := "new.txt" - os.WriteFile(testFile, []byte("content"), 0644) - - // Commit with auto-generated message (empty string) - err := gitCommit(ctx, testFile, "") - if err != nil { - t.Fatalf("gitCommit() error = %v", err) - } - - // Verify it committed (message generation worked) - cmd := exec.Command("git", "log", "-1", "--pretty=%B") - output, _ := cmd.Output() - if len(output) == 0 { - t.Error("expected commit message to be generated") - } -} - -func TestCountIssuesInJSONL_NonExistent(t *testing.T) { - t.Parallel() - count, err := countIssuesInJSONL("/nonexistent/path.jsonl") - if err == nil { - t.Error("expected error for nonexistent file") - } - if count != 0 { - t.Errorf("count = %d, want 0 on error", count) - } -} - -func TestCountIssuesInJSONL_EmptyFile(t *testing.T) { - t.Parallel() - tmpDir := t.TempDir() - jsonlPath := filepath.Join(tmpDir, "empty.jsonl") - os.WriteFile(jsonlPath, []byte(""), 0644) - - count, err := countIssuesInJSONL(jsonlPath) - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - if count != 0 { - t.Errorf("count = %d, want 0", count) - } -} - -func TestCountIssuesInJSONL_MultipleIssues(t *testing.T) { - t.Parallel() - tmpDir := t.TempDir() - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - content := `{"id":"bd-1"} -{"id":"bd-2"} -{"id":"bd-3"} -` - os.WriteFile(jsonlPath, []byte(content), 0644) - - count, err := countIssuesInJSONL(jsonlPath) - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - if count != 3 { - t.Errorf("count = %d, want 3", count) - } -} - -func TestCountIssuesInJSONL_WithMalformedLines(t *testing.T) { - t.Parallel() - tmpDir := t.TempDir() - jsonlPath := filepath.Join(tmpDir, "mixed.jsonl") - content := `{"id":"bd-1"} -not valid json -{"id":"bd-2"} -{"id":"bd-3"} -` - os.WriteFile(jsonlPath, []byte(content), 0644) - - count, err := countIssuesInJSONL(jsonlPath) - // countIssuesInJSONL returns error on malformed JSON - if err == nil { - t.Error("expected error for malformed JSON") - } - // Should have counted the first valid issue before hitting error - if count != 1 { - t.Errorf("count = %d, want 1 (before malformed line)", count) - } -} - -func TestGetCurrentBranch(t *testing.T) { - ctx := context.Background() - _, cleanup := setupGitRepo(t) - defer cleanup() - - // Get current branch - branch, err := getCurrentBranch(ctx) - if err != nil { - t.Fatalf("getCurrentBranch() error = %v", err) - } - - // Default branch is usually main or master - if branch != "main" && branch != "master" { - t.Logf("got branch %s (expected main or master, but this can vary)", branch) - } -} - -func TestMergeSyncBranch_NoSyncBranchConfigured(t *testing.T) { - ctx := context.Background() - _, cleanup := setupGitRepo(t) - defer cleanup() - - // Try to merge without sync.branch configured (or database) - err := mergeSyncBranch(ctx, false) - if err == nil { - t.Error("expected error when sync.branch not configured") - } - // Error could be about missing database or missing sync.branch config - if err != nil && !strings.Contains(err.Error(), "sync.branch") && !strings.Contains(err.Error(), "database") { - t.Errorf("expected error about sync.branch or database, got: %v", err) - } -} - -func TestMergeSyncBranch_OnSyncBranch(t *testing.T) { - ctx := context.Background() - tmpDir, cleanup := setupGitRepo(t) - defer cleanup() - - // Create sync branch - exec.Command("git", "checkout", "-b", "beads-metadata").Run() - - // Initialize bd database and set sync.branch - beadsDir := filepath.Join(tmpDir, ".beads") - os.MkdirAll(beadsDir, 0755) - - // This test will fail with store access issues, so we just verify the branch check - // The actual merge functionality is tested in integration tests - currentBranch, _ := getCurrentBranch(ctx) - if currentBranch != "beads-metadata" { - t.Skipf("test setup failed, current branch is %s", currentBranch) - } -} - -func TestMergeSyncBranch_DirtyWorkingTree(t *testing.T) { - _, cleanup := setupGitRepo(t) - defer cleanup() - - // Create uncommitted changes - os.WriteFile("test.txt", []byte("modified"), 0644) - - // This test verifies the dirty working tree check would work - // (We can't test the full merge without database setup) - statusCmd := exec.Command("git", "status", "--porcelain") - output, _ := statusCmd.Output() - if len(output) == 0 { - t.Error("expected dirty working tree for test setup") - } -} - -func TestGetSyncBranch_EnvOverridesDB(t *testing.T) { - ctx := context.Background() - - // Save and restore global store state - oldStore := store - storeMutex.Lock() - oldStoreActive := storeActive - storeMutex.Unlock() - oldDBPath := dbPath - - // Use a temp dir for Dolt store (Dolt doesn't support :memory:) - testStore, err := dolt.New(context.Background(), &dolt.Config{Path: filepath.Join(t.TempDir(), "test.db")}) - if err != nil { - t.Fatalf("failed to create test store: %v", err) - } - defer testStore.Close() - - // Seed DB config and globals - if err := testStore.SetConfig(ctx, "sync.branch", "db-branch"); err != nil { - t.Fatalf("failed to set sync.branch in db: %v", err) - } - - storeMutex.Lock() - store = testStore - storeActive = true - storeMutex.Unlock() - dbPath = "" // avoid FindDatabasePath in ensureStoreActive - - // Set environment override - if err := os.Setenv(syncbranch.EnvVar, "env-branch"); err != nil { - t.Fatalf("failed to set %s: %v", syncbranch.EnvVar, err) - } - defer os.Unsetenv(syncbranch.EnvVar) - - // Ensure we restore globals after the test - defer func() { - storeMutex.Lock() - store = oldStore - storeActive = oldStoreActive - storeMutex.Unlock() - dbPath = oldDBPath - }() - - branch, err := getSyncBranch(ctx) - if err != nil { - t.Fatalf("getSyncBranch() error = %v", err) - } - if branch != "env-branch" { - t.Errorf("getSyncBranch() = %q, want %q (env override)", branch, "env-branch") - } -} - -func TestIsInRebase_NotInRebase(t *testing.T) { - _, cleanup := setupGitRepo(t) - defer cleanup() - - // Should not be in rebase - if isInRebase() { - t.Error("expected false when not in rebase") - } -} - -func TestIsInRebase_InRebase(t *testing.T) { - tmpDir, cleanup := setupGitRepo(t) - defer cleanup() - - // Simulate rebase by creating rebase-merge directory - os.MkdirAll(filepath.Join(tmpDir, ".git", "rebase-merge"), 0755) - - // Should detect rebase - if !isInRebase() { - t.Error("expected true when .git/rebase-merge exists") - } -} - -func TestIsInRebase_InRebaseApply(t *testing.T) { - tmpDir, cleanup := setupMinimalGitRepo(t) - defer cleanup() - - // Simulate non-interactive rebase by creating rebase-apply directory - os.MkdirAll(filepath.Join(tmpDir, ".git", "rebase-apply"), 0755) - - // Should detect rebase - if !isInRebase() { - t.Error("expected true when .git/rebase-apply exists") - } -} - -func TestHasJSONLConflict_NoConflict(t *testing.T) { - _, cleanup := setupGitRepo(t) - defer cleanup() - - // Should not have JSONL conflict - if hasJSONLConflict() { - t.Error("expected false when no conflicts") - } -} - -func TestHasJSONLConflict_OnlyJSONLConflict(t *testing.T) { - tmpDir, cleanup := setupGitRepoWithBranch(t, "main") - defer cleanup() - - // Create initial commit with beads.jsonl - beadsDir := filepath.Join(tmpDir, ".beads") - os.MkdirAll(beadsDir, 0755) - os.WriteFile(filepath.Join(beadsDir, "beads.jsonl"), []byte(`{"id":"bd-1","title":"original"}`), 0644) - exec.Command("git", "add", ".").Run() - exec.Command("git", "commit", "-m", "add beads.jsonl").Run() - - // Create a second commit on main (modify same issue) - os.WriteFile(filepath.Join(beadsDir, "beads.jsonl"), []byte(`{"id":"bd-1","title":"main-version"}`), 0644) - exec.Command("git", "add", ".").Run() - exec.Command("git", "commit", "-m", "main change").Run() - - // Create a branch from the first commit - exec.Command("git", "checkout", "-b", "feature", "HEAD~1").Run() - os.WriteFile(filepath.Join(beadsDir, "beads.jsonl"), []byte(`{"id":"bd-1","title":"feature-version"}`), 0644) - exec.Command("git", "add", ".").Run() - exec.Command("git", "commit", "-m", "feature change").Run() - - // Attempt rebase onto main (will conflict) - exec.Command("git", "rebase", "main").Run() - - // Should detect JSONL conflict during rebase - if !hasJSONLConflict() { - t.Error("expected true when only beads.jsonl has conflict during rebase") - } -} - -func TestHasJSONLConflict_MultipleConflicts(t *testing.T) { - tmpDir, cleanup := setupGitRepoWithBranch(t, "main") - defer cleanup() - - // Create initial commit with beads.jsonl and another file - beadsDir := filepath.Join(tmpDir, ".beads") - os.MkdirAll(beadsDir, 0755) - os.WriteFile(filepath.Join(beadsDir, "beads.jsonl"), []byte(`{"id":"bd-1","title":"original"}`), 0644) - os.WriteFile("other.txt", []byte("line1\nline2\nline3"), 0644) - exec.Command("git", "add", ".").Run() - exec.Command("git", "commit", "-m", "add initial files").Run() - - // Create a second commit on main (modify both files) - os.WriteFile(filepath.Join(beadsDir, "beads.jsonl"), []byte(`{"id":"bd-1","title":"main-version"}`), 0644) - os.WriteFile("other.txt", []byte("line1\nmain-version\nline3"), 0644) - exec.Command("git", "add", ".").Run() - exec.Command("git", "commit", "-m", "main change").Run() - - // Create a branch from the first commit - exec.Command("git", "checkout", "-b", "feature", "HEAD~1").Run() - os.WriteFile(filepath.Join(beadsDir, "beads.jsonl"), []byte(`{"id":"bd-1","title":"feature-version"}`), 0644) - os.WriteFile("other.txt", []byte("line1\nfeature-version\nline3"), 0644) - exec.Command("git", "add", ".").Run() - exec.Command("git", "commit", "-m", "feature change").Run() - - // Attempt rebase (will conflict on both files) - exec.Command("git", "rebase", "main").Run() - - // Should NOT auto-resolve when multiple files conflict - if hasJSONLConflict() { - t.Error("expected false when multiple files have conflicts (should not auto-resolve)") - } -} - -// Note: TestZFCSkipsExportAfterImport was removed as ZFC checks are no longer part of the -// legacy sync flow. Use --pull-first for structural staleness handling via 3-way merge. - -// TestHashBasedStalenessDetection_bd_f2f tests the bd-f2f fix: -// When JSONL content differs from stored hash (e.g., remote changed status), -// hasJSONLChanged should detect the mismatch even if counts are equal. -func TestHashBasedStalenessDetection_bd_f2f(t *testing.T) { - ctx := context.Background() - tmpDir := t.TempDir() - - // Create test database - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("failed to create beads dir: %v", err) - } - - testDBPath := filepath.Join(beadsDir, "beads.db") - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - - // Create store - testStore, err := dolt.New(ctx, &dolt.Config{Path: testDBPath}) - if err != nil { - t.Fatalf("failed to create store: %v", err) - } - defer testStore.Close() - - // Initialize issue prefix (required for creating issues) - if err := testStore.SetConfig(ctx, "issue_prefix", "test"); err != nil { - t.Fatalf("failed to set issue prefix: %v", err) - } - - // Create an issue in DB (simulating stale DB with old content) - issue := &types.Issue{ - ID: "test-abc", - Title: "Test Issue", - Status: types.StatusOpen, - Priority: 1, // DB has priority 1 - IssueType: types.TypeTask, - } - if err := testStore.CreateIssue(ctx, issue, "test"); err != nil { - t.Fatalf("failed to create issue: %v", err) - } - - // Create JSONL with same issue but different priority (correct remote state) - // This simulates what happens after git pull brings in updated JSONL - // (e.g., remote changed priority from 1 to 0) - jsonlContent := `{"id":"test-abc","title":"Test Issue","status":"open","priority":0,"type":"task"} -` - if err := os.WriteFile(jsonlPath, []byte(jsonlContent), 0600); err != nil { - t.Fatalf("failed to write JSONL: %v", err) - } - - // Store an OLD hash (different from current JSONL) - // This simulates the case where JSONL was updated externally (by git pull) - // but DB still has old hash from before the pull - oldHash := "0000000000000000000000000000000000000000000000000000000000000000" - if err := testStore.SetMetadata(ctx, "jsonl_content_hash", oldHash); err != nil { - t.Fatalf("failed to set old hash: %v", err) - } - - // Verify counts are equal (1 issue in both) - dbCount, err := countDBIssuesFast(ctx, testStore) - if err != nil { - t.Fatalf("failed to count DB issues: %v", err) - } - jsonlCount, err := countIssuesInJSONL(jsonlPath) - if err != nil { - t.Fatalf("failed to count JSONL issues: %v", err) - } - if dbCount != jsonlCount { - t.Fatalf("setup error: expected equal counts, got DB=%d, JSONL=%d", dbCount, jsonlCount) - } - - // The key test: hasJSONLChanged should detect the hash mismatch - // even though counts are equal - repoKey := getRepoKeyForPath(jsonlPath) - changed := hasJSONLChanged(ctx, testStore, jsonlPath, repoKey) - - if !changed { - t.Error("bd-f2f: hasJSONLChanged should return true when JSONL hash differs from stored hash") - t.Log("This is the bug scenario: counts match (1 == 1) but content differs (priority=1 vs priority=0)") - t.Log("Without the bd-f2f fix, the stale DB would export old content and corrupt the remote") - } else { - t.Log("✓ bd-f2f fix verified: hash mismatch detected even with equal counts") - } - - // Verify that after updating hash, hasJSONLChanged returns false - currentHash, err := computeJSONLHash(jsonlPath) - if err != nil { - t.Fatalf("failed to compute current hash: %v", err) - } - if err := testStore.SetMetadata(ctx, "jsonl_content_hash", currentHash); err != nil { - t.Fatalf("failed to set current hash: %v", err) - } - - changedAfterUpdate := hasJSONLChanged(ctx, testStore, jsonlPath, repoKey) - if changedAfterUpdate { - t.Error("hasJSONLChanged should return false after hash is updated to match JSONL") - } -} - -// TestResolveNoGitHistoryForFromMain tests that --from-main forces noGitHistory=true -// to prevent creating incorrect deletion records for locally-created beads. -// See: https://github.com/steveyegge/beads/issues/417 -func TestResolveNoGitHistoryForFromMain(t *testing.T) { - t.Parallel() - tests := []struct { - name string - fromMain bool - noGitHistory bool - want bool - }{ - { - name: "fromMain=true forces noGitHistory=true regardless of flag", - fromMain: true, - noGitHistory: false, - want: true, - }, - { - name: "fromMain=true with noGitHistory=true stays true", - fromMain: true, - noGitHistory: true, - want: true, - }, - { - name: "fromMain=false preserves noGitHistory=false", - fromMain: false, - noGitHistory: false, - want: false, - }, - { - name: "fromMain=false preserves noGitHistory=true", - fromMain: false, - noGitHistory: true, - want: true, - }, - } - - for _, tt := range tests { - tt := tt // capture range variable - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - got := resolveNoGitHistoryForFromMain(tt.fromMain, tt.noGitHistory) - if got != tt.want { - t.Errorf("resolveNoGitHistoryForFromMain(%v, %v) = %v, want %v", - tt.fromMain, tt.noGitHistory, got, tt.want) - } - }) - } -} - -// TestGetGitCommonDir tests that getGitCommonDir correctly returns the shared -// git directory for both regular repos and worktrees. -func TestGetGitCommonDir(t *testing.T) { - ctx := context.Background() - - // Test 1: Regular repo - t.Run("regular repo", func(t *testing.T) { - repoDir, cleanup := setupGitRepo(t) - defer cleanup() - - commonDir, err := getGitCommonDir(ctx, repoDir) - if err != nil { - t.Fatalf("getGitCommonDir failed: %v", err) - } - - // For a regular repo, git-common-dir should point to .git - expectedGitDir := filepath.Join(repoDir, ".git") - // Resolve symlinks for comparison (macOS /var -> /private/var) - if resolved, err := filepath.EvalSymlinks(expectedGitDir); err == nil { - expectedGitDir = resolved - } - if commonDir != expectedGitDir { - t.Errorf("getGitCommonDir = %q, want %q", commonDir, expectedGitDir) - } - }) - - // Test 2: Worktree (non-bare) shares common dir with main repo - t.Run("worktree shares common dir with main repo", func(t *testing.T) { - repoDir, cleanup := setupGitRepo(t) - defer cleanup() - - // Create a branch for the worktree - if err := exec.Command("git", "-C", repoDir, "branch", "test-branch").Run(); err != nil { - t.Fatalf("git branch failed: %v", err) - } - - // Create worktree - worktreeDir := filepath.Join(t.TempDir(), "worktree") - if output, err := exec.Command("git", "-C", repoDir, "worktree", "add", worktreeDir, "test-branch").CombinedOutput(); err != nil { - t.Fatalf("git worktree add failed: %v\n%s", err, output) - } - - // Get common dir for both - mainCommonDir, err := getGitCommonDir(ctx, repoDir) - if err != nil { - t.Fatalf("getGitCommonDir(main) failed: %v", err) - } - - worktreeCommonDir, err := getGitCommonDir(ctx, worktreeDir) - if err != nil { - t.Fatalf("getGitCommonDir(worktree) failed: %v", err) - } - - // Both should return the same common dir - if mainCommonDir != worktreeCommonDir { - t.Errorf("common dirs differ: main=%q, worktree=%q", mainCommonDir, worktreeCommonDir) - } - }) -} - -// TestIsExternalBeadsDir tests that isExternalBeadsDir correctly identifies -// when beads directory is in the same vs different git repo. -// GH#810: This was broken for bare repo worktrees. -func TestIsExternalBeadsDir(t *testing.T) { - ctx := context.Background() - - // Test 1: Same directory - not external - t.Run("same directory is not external", func(t *testing.T) { - repoDir, cleanup := setupGitRepo(t) - defer cleanup() - - beadsDir := filepath.Join(repoDir, ".beads") - if err := os.MkdirAll(beadsDir, 0750); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - // Change to the repo directory (isExternalBeadsDir uses cwd) - origDir, _ := os.Getwd() - if err := os.Chdir(repoDir); err != nil { - t.Fatalf("chdir failed: %v", err) - } - defer func() { _ = os.Chdir(origDir) }() - - if isExternalBeadsDir(ctx, beadsDir) { - t.Error("expected local beads dir to not be external") - } - }) - - // Test 2: Different repo - is external - t.Run("different repo is external", func(t *testing.T) { - repo1Dir, cleanup1 := setupGitRepo(t) - defer cleanup1() - repo2Dir, cleanup2 := setupGitRepo(t) - defer cleanup2() - - beadsDir := filepath.Join(repo2Dir, ".beads") - if err := os.MkdirAll(beadsDir, 0750); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - // Change to repo1 - origDir, _ := os.Getwd() - if err := os.Chdir(repo1Dir); err != nil { - t.Fatalf("chdir failed: %v", err) - } - defer func() { _ = os.Chdir(origDir) }() - - if !isExternalBeadsDir(ctx, beadsDir) { - t.Error("expected beads dir in different repo to be external") - } - }) - - // Test 3: Worktree with beads - not external (GH#810 fix) - t.Run("worktree beads dir is not external", func(t *testing.T) { - repoDir, cleanup := setupGitRepo(t) - defer cleanup() - - // Create a branch for the worktree - if err := exec.Command("git", "-C", repoDir, "branch", "test-branch").Run(); err != nil { - t.Fatalf("git branch failed: %v", err) - } - - // Create worktree - worktreeDir := filepath.Join(t.TempDir(), "worktree") - if output, err := exec.Command("git", "-C", repoDir, "worktree", "add", worktreeDir, "test-branch").CombinedOutput(); err != nil { - t.Fatalf("git worktree add failed: %v\n%s", err, output) - } - - // Create beads dir in worktree - beadsDir := filepath.Join(worktreeDir, ".beads") - if err := os.MkdirAll(beadsDir, 0750); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - - // Change to worktree - origDir, _ := os.Getwd() - if err := os.Chdir(worktreeDir); err != nil { - t.Fatalf("chdir failed: %v", err) - } - defer func() { _ = os.Chdir(origDir) }() - - // Beads dir in same worktree should NOT be external - if isExternalBeadsDir(ctx, beadsDir) { - t.Error("expected beads dir in same worktree to not be external") - } - }) -} - -// TestConcurrentEdit tests the pull-first sync flow with concurrent edits. -// This validates the 3-way merge logic for the pull-first sync refactor (#911). -// -// Scenario: -// - Base state exists (issue bd-1 at version 2025-01-01) -// - Local modifies issue (version 2025-01-02) -// - Remote also modifies issue (version 2025-01-03) -// - 3-way merge detects conflict and resolves using LWW (remote wins) -func TestConcurrentEdit(t *testing.T) { - ctx := context.Background() - tmpDir := newGitRepo(t) - t.Chdir(tmpDir) - - // Setup: Create beads directory with JSONL (base state) - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - - // Base state: single issue at 2025-01-01 - baseTime := time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC) - baseIssue := `{"id":"bd-1","title":"Original Title","status":"open","issue_type":"task","priority":2,"created_at":"2025-01-01T00:00:00Z","updated_at":"2025-01-01T00:00:00Z"}` - if err := os.WriteFile(jsonlPath, []byte(baseIssue+"\n"), 0644); err != nil { - t.Fatalf("write JSONL failed: %v", err) - } - - // Initial commit - _ = exec.Command("git", "add", ".").Run() - if err := exec.Command("git", "commit", "-m", "initial").Run(); err != nil { - t.Fatalf("initial commit failed: %v", err) - } - - // Create database and import base state - testDBPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: testDBPath}) - if err != nil { - t.Fatalf("failed to create test store: %v", err) - } - defer testStore.Close() - - // Set issue_prefix - if err := testStore.SetConfig(ctx, "issue_prefix", "bd"); err != nil { - t.Fatalf("failed to set issue_prefix: %v", err) - } - - // Load base state for 3-way merge - baseIssues, err := loadIssuesFromJSONL(jsonlPath) - if err != nil { - t.Fatalf("loadIssuesFromJSONL (base) failed: %v", err) - } - - // Create local issue (modified at 2025-01-02) - localTime := time.Date(2025, 1, 2, 0, 0, 0, 0, time.UTC) - localIssueObj := &types.Issue{ - ID: "bd-1", - Title: "Local Edit", - Status: types.StatusOpen, - IssueType: types.TypeTask, - Priority: 2, - CreatedAt: baseTime, - UpdatedAt: localTime, - } - localIssues := []*types.Issue{localIssueObj} - - // Simulate "remote" edit: change title in JSONL (modified at 2025-01-03 - later) - remoteIssue := `{"id":"bd-1","title":"Remote Edit","status":"open","issue_type":"task","priority":2,"created_at":"2025-01-01T00:00:00Z","updated_at":"2025-01-03T00:00:00Z"}` - if err := os.WriteFile(jsonlPath, []byte(remoteIssue+"\n"), 0644); err != nil { - t.Fatalf("write remote JSONL failed: %v", err) - } - - remoteIssues, err := loadIssuesFromJSONL(jsonlPath) - if err != nil { - t.Fatalf("loadIssuesFromJSONL (remote) failed: %v", err) - } - - if len(remoteIssues) != 1 { - t.Fatalf("expected 1 remote issue, got %d", len(remoteIssues)) - } - - // 3-way merge with base state - mergeResult := MergeIssues(baseIssues, localIssues, remoteIssues) - - // Verify merge result - if len(mergeResult.Merged) != 1 { - t.Fatalf("expected 1 merged issue, got %d", len(mergeResult.Merged)) - } - - // LWW: Remote wins because it has later updated_at (2025-01-03 > 2025-01-02) - if mergeResult.Merged[0].Title != "Remote Edit" { - t.Errorf("expected merged title 'Remote Edit' (remote wins LWW), got '%s'", mergeResult.Merged[0].Title) - } - - // Verify strategy: should be "merged" (conflict resolved by LWW) - if mergeResult.Strategy["bd-1"] != StrategyMerged { - t.Errorf("expected strategy '%s' for bd-1, got '%s'", StrategyMerged, mergeResult.Strategy["bd-1"]) - } - - // Verify 1 conflict was detected and resolved - if mergeResult.Conflicts != 1 { - t.Errorf("expected 1 conflict (both sides modified), got %d", mergeResult.Conflicts) - } - - t.Log("TestConcurrentEdit: 3-way merge with LWW resolution validated") -} - -// TestConcurrentSyncBlocked tests that concurrent syncs are blocked by file lock. -// This validates the P0 fix for preventing data corruption when running bd sync -// from multiple terminals simultaneously. -func TestConcurrentSyncBlocked(t *testing.T) { - ctx := context.Background() - tmpDir := newGitRepo(t) - t.Chdir(tmpDir) - - // Setup: Create beads directory with JSONL - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatalf("mkdir failed: %v", err) - } - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - - // Create initial JSONL - if err := os.WriteFile(jsonlPath, []byte(`{"id":"bd-1","title":"Test"}`+"\n"), 0644); err != nil { - t.Fatalf("write JSONL failed: %v", err) - } - - // Initial commit - _ = exec.Command("git", "add", ".").Run() - if err := exec.Command("git", "commit", "-m", "initial").Run(); err != nil { - t.Fatalf("initial commit failed: %v", err) - } - - // Create database - testDBPath := filepath.Join(beadsDir, "beads.db") - testStore, err := dolt.New(ctx, &dolt.Config{Path: testDBPath}) - if err != nil { - t.Fatalf("failed to create test store: %v", err) - } - defer testStore.Close() - - // Set issue_prefix - if err := testStore.SetConfig(ctx, "issue_prefix", "bd"); err != nil { - t.Fatalf("failed to set issue_prefix: %v", err) - } - - // Simulate another sync holding the lock - lockPath := filepath.Join(beadsDir, ".sync.lock") - lock := flock.New(lockPath) - locked, err := lock.TryLock() - if err != nil { - t.Fatalf("failed to acquire lock: %v", err) - } - if !locked { - t.Fatal("expected to acquire lock") - } - - // Now try to acquire the same lock (simulating concurrent sync) - lock2 := flock.New(lockPath) - locked2, err := lock2.TryLock() - if err != nil { - t.Fatalf("TryLock error: %v", err) - } - - // Second lock attempt should fail (not block) - if locked2 { - lock2.Unlock() - t.Error("expected second lock attempt to fail (concurrent sync should be blocked)") - } else { - t.Log("Concurrent sync correctly blocked by file lock") - } - - // Release first lock - if err := lock.Unlock(); err != nil { - t.Fatalf("failed to unlock: %v", err) - } - - // Now lock should be acquirable again - lock3 := flock.New(lockPath) - locked3, err := lock3.TryLock() - if err != nil { - t.Fatalf("TryLock error after unlock: %v", err) - } - if !locked3 { - t.Error("expected lock to be acquirable after first sync completes") - } else { - lock3.Unlock() - t.Log("Lock correctly acquirable after first sync completes") - } -} diff --git a/cmd/bd/sync_validation_test.go b/cmd/bd/sync_validation_test.go deleted file mode 100644 index 51c1ce473..000000000 --- a/cmd/bd/sync_validation_test.go +++ /dev/null @@ -1,265 +0,0 @@ -//go:build cgo - -package main - -import ( - "context" - "path/filepath" - "strings" - "testing" - - "github.com/steveyegge/beads/internal/config" - "github.com/steveyegge/beads/internal/types" -) - -// setupSyncValidationTest creates a test store and properly initializes globals. -// Returns the store and a cleanup function that should be deferred. -func setupSyncValidationTest(t *testing.T) (*testing.T, func()) { - t.Helper() - - tmpDir := t.TempDir() - testDBPath := filepath.Join(tmpDir, ".beads", "issues.db") - - testStore := newTestStore(t, testDBPath) - - // Save original state - origStore := store - origStoreActive := storeActive - origDBPath := dbPath - - // Set up test state - store = testStore - storeMutex.Lock() - storeActive = true - storeMutex.Unlock() - dbPath = testDBPath - - cleanup := func() { - storeMutex.Lock() - store = origStore - storeActive = origStoreActive - storeMutex.Unlock() - dbPath = origDBPath - } - - return t, cleanup -} - -// TestValidateOpenIssuesForSync_ModeNone verifies validation is skipped when -// validation.on-sync is set to "none" (default). -func TestValidateOpenIssuesForSync_ModeNone(t *testing.T) { - _, cleanup := setupSyncValidationTest(t) - defer cleanup() - - // Create a bug without required sections (should fail validation) - ctx := context.Background() - issue := &types.Issue{ - ID: "test-001", - Title: "Bug without sections", - IssueType: types.TypeBug, - Description: "No steps to reproduce or acceptance criteria", - Status: types.StatusOpen, - } - if err := store.CreateIssue(ctx, issue, "test-user"); err != nil { - t.Fatalf("CreateIssue: %v", err) - } - - // Set validation mode to "none" - initConfigForTest(t) - config.Set("validation.on-sync", "none") - - // Should return nil (skip validation) - err := validateOpenIssuesForSync(ctx) - if err != nil { - t.Errorf("validateOpenIssuesForSync with mode=none returned error: %v", err) - } -} - -// TestValidateOpenIssuesForSync_ModeEmpty verifies validation is skipped when -// validation.on-sync is empty (backwards compatibility). -func TestValidateOpenIssuesForSync_ModeEmpty(t *testing.T) { - _, cleanup := setupSyncValidationTest(t) - defer cleanup() - - // Create a bug without required sections - ctx := context.Background() - issue := &types.Issue{ - ID: "test-001", - Title: "Bug without sections", - IssueType: types.TypeBug, - Description: "No sections", - Status: types.StatusOpen, - } - if err := store.CreateIssue(ctx, issue, "test-user"); err != nil { - t.Fatalf("CreateIssue: %v", err) - } - - // Set validation mode to empty string - initConfigForTest(t) - config.Set("validation.on-sync", "") - - // Should return nil (skip validation) - err := validateOpenIssuesForSync(ctx) - if err != nil { - t.Errorf("validateOpenIssuesForSync with mode=empty returned error: %v", err) - } -} - -// TestValidateOpenIssuesForSync_ModeWarn verifies sync proceeds when -// validation.on-sync is "warn" even with invalid issues. -func TestValidateOpenIssuesForSync_ModeWarn(t *testing.T) { - _, cleanup := setupSyncValidationTest(t) - defer cleanup() - - // Create a bug without required sections - ctx := context.Background() - issue := &types.Issue{ - ID: "test-001", - Title: "Bug without sections", - IssueType: types.TypeBug, - Description: "No steps to reproduce or acceptance criteria", - Status: types.StatusOpen, - } - if err := store.CreateIssue(ctx, issue, "test-user"); err != nil { - t.Fatalf("CreateIssue: %v", err) - } - - // Set validation mode to "warn" - initConfigForTest(t) - config.Set("validation.on-sync", "warn") - - // Should return nil (warnings printed but sync proceeds) - // The function prints to stderr but returns nil to allow sync to continue - err := validateOpenIssuesForSync(ctx) - if err != nil { - t.Errorf("validateOpenIssuesForSync with mode=warn should return nil, got: %v", err) - } -} - -// TestValidateOpenIssuesForSync_ModeError verifies sync is blocked when -// validation.on-sync is "error" and issues fail validation. -func TestValidateOpenIssuesForSync_ModeError(t *testing.T) { - _, cleanup := setupSyncValidationTest(t) - defer cleanup() - - // Create a bug without required sections - ctx := context.Background() - issue := &types.Issue{ - ID: "test-001", - Title: "Bug without sections", - IssueType: types.TypeBug, - Description: "No sections at all", - Status: types.StatusOpen, - } - if err := store.CreateIssue(ctx, issue, "test-user"); err != nil { - t.Fatalf("CreateIssue: %v", err) - } - - // Set validation mode to "error" - initConfigForTest(t) - config.Set("validation.on-sync", "error") - - // Should return error (function also prints to stderr which we allow) - err := validateOpenIssuesForSync(ctx) - - if err == nil { - t.Error("validateOpenIssuesForSync with mode=error should return error for invalid issues") - } - if !strings.Contains(err.Error(), "template validation failed") { - t.Errorf("expected 'template validation failed' in error, got: %v", err) - } -} - -// TestValidateOpenIssuesForSync_NoWarnings verifies no errors when all issues pass validation. -func TestValidateOpenIssuesForSync_NoWarnings(t *testing.T) { - _, cleanup := setupSyncValidationTest(t) - defer cleanup() - - // Create a bug WITH all required sections - ctx := context.Background() - issue := &types.Issue{ - ID: "test-001", - Title: "Bug with sections", - IssueType: types.TypeBug, - Description: `## Steps to Reproduce -1. Do this -2. Do that - -## Acceptance Criteria -- It works`, - Status: types.StatusOpen, - } - if err := store.CreateIssue(ctx, issue, "test-user"); err != nil { - t.Fatalf("CreateIssue: %v", err) - } - - // Set validation mode to "error" (strictest mode) - initConfigForTest(t) - config.Set("validation.on-sync", "error") - - // Should return nil (no validation errors) - err := validateOpenIssuesForSync(ctx) - if err != nil { - t.Errorf("validateOpenIssuesForSync should not return error for valid issues: %v", err) - } -} - -// TestValidateOpenIssuesForSync_SkipsClosedIssues verifies closed issues are not validated. -func TestValidateOpenIssuesForSync_SkipsClosedIssues(t *testing.T) { - _, cleanup := setupSyncValidationTest(t) - defer cleanup() - - ctx := context.Background() - - // Create a closed bug without required sections (should be skipped) - closedIssue := &types.Issue{ - ID: "test-001", - Title: "Closed bug without sections", - IssueType: types.TypeBug, - Description: "No sections", - Status: types.StatusClosed, - } - if err := store.CreateIssue(ctx, closedIssue, "test-user"); err != nil { - t.Fatalf("CreateIssue: %v", err) - } - - // Set validation mode to "error" - initConfigForTest(t) - config.Set("validation.on-sync", "error") - - // Should return nil (closed issues are not validated) - err := validateOpenIssuesForSync(ctx) - if err != nil { - t.Errorf("validateOpenIssuesForSync should skip closed issues: %v", err) - } -} - -// TestValidateOpenIssuesForSync_ChoreHasNoRequirements verifies chore type -// has no required sections and passes validation. -func TestValidateOpenIssuesForSync_ChoreHasNoRequirements(t *testing.T) { - _, cleanup := setupSyncValidationTest(t) - defer cleanup() - - // Create a chore without any sections (should pass - no requirements) - ctx := context.Background() - issue := &types.Issue{ - ID: "test-001", - Title: "Chore issue", - IssueType: types.TypeChore, - Description: "Just a description, no sections needed", - Status: types.StatusOpen, - } - if err := store.CreateIssue(ctx, issue, "test-user"); err != nil { - t.Fatalf("CreateIssue: %v", err) - } - - // Set validation mode to "error" - initConfigForTest(t) - config.Set("validation.on-sync", "error") - - // Should return nil (chore has no requirements) - err := validateOpenIssuesForSync(ctx) - if err != nil { - t.Errorf("validateOpenIssuesForSync should not error for chore issues: %v", err) - } -} diff --git a/cmd/bd/tips.go b/cmd/bd/tips.go index 5b016ff52..31320e72a 100644 --- a/cmd/bd/tips.go +++ b/cmd/bd/tips.go @@ -14,7 +14,6 @@ import ( "sync" "time" - "github.com/steveyegge/beads/internal/beads" "github.com/steveyegge/beads/internal/storage/dolt" ) @@ -393,16 +392,9 @@ func initDefaultTips() { } // syncConflictCondition checks if there's a sync conflict that needs manual resolution. -// This is the condition function for the sync_conflict tip. +// Sync conflict tracking was removed — always returns false. func syncConflictCondition() bool { - // Find beads directory to check sync state - beadsDir := beads.FindBeadsDir() - if beadsDir == "" { - return false - } - - state := LoadSyncState(beadsDir) - return state.NeedsManualSync + return false } // init initializes the tip system with default tips