feat: implement amp AI tool support and replace Taskfile with Magev0.10.0

- Add amp as default AI tool for release notes and showcase generation
- Fallback chain: amp → hexai → claude → aichat
- Replace Taskfile.yaml with magefile.go for build automation
- Update all documentation (README.md, AGENTS.md, doc/development.md)
- Update version to 0.10.0

Amp-Thread-ID: https://ampcode.com/threads/T-735ba1e2-0255-4b43-8ed1-6c0d2f78301b
Co-authored-by: Amp <amp@ampcode.com>

8 files changed, 520 insertions, 522 deletions

diff --git a/internal/cli/description_cache.go b/internal/cli/description_cache.go
index 1cfc951..a2ce9ab 100644
--- a/internal/cli/description_cache.go
+++ b/internal/cli/description_cache.go
@@ -1,38 +1,37 @@
 package cli
 
 import (
-    "encoding/json"
-    "fmt"
-    "os"
-    "path/filepath"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
 )
 
 // loadDescriptionCache loads the per-repo canonical description cache
 func loadDescriptionCache(workDir string) map[string]string {
-    cache := make(map[string]string)
-    cacheFile := filepath.Join(workDir, ".gitsyncer-descriptions-cache.json")
-    data, err := os.ReadFile(cacheFile)
-    if err != nil {
-        return cache
-    }
-    if err := json.Unmarshal(data, &cache); err != nil {
-        fmt.Printf("Warning: Failed to parse descriptions cache: %v\n", err)
-        return make(map[string]string)
-    }
-    fmt.Printf("Loaded descriptions cache with %d entries\n", len(cache))
-    return cache
+	cache := make(map[string]string)
+	cacheFile := filepath.Join(workDir, ".gitsyncer-descriptions-cache.json")
+	data, err := os.ReadFile(cacheFile)
+	if err != nil {
+		return cache
+	}
+	if err := json.Unmarshal(data, &cache); err != nil {
+		fmt.Printf("Warning: Failed to parse descriptions cache: %v\n", err)
+		return make(map[string]string)
+	}
+	fmt.Printf("Loaded descriptions cache with %d entries\n", len(cache))
+	return cache
 }
 
 // saveDescriptionCache saves the per-repo canonical description cache
 func saveDescriptionCache(workDir string, cache map[string]string) error {
-    cacheFile := filepath.Join(workDir, ".gitsyncer-descriptions-cache.json")
-    data, err := json.MarshalIndent(cache, "", "  ")
-    if err != nil {
-        return fmt.Errorf("failed to marshal descriptions cache: %w", err)
-    }
-    if err := os.WriteFile(cacheFile, data, 0644); err != nil {
-        return fmt.Errorf("failed to write descriptions cache: %w", err)
-    }
-    return nil
+	cacheFile := filepath.Join(workDir, ".gitsyncer-descriptions-cache.json")
+	data, err := json.MarshalIndent(cache, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal descriptions cache: %w", err)
+	}
+	if err := os.WriteFile(cacheFile, data, 0644); err != nil {
+		return fmt.Errorf("failed to write descriptions cache: %w", err)
+	}
+	return nil
 }
-
diff --git a/internal/cli/description_sync.go b/internal/cli/description_sync.go
index ae275ce..4904b56 100644
--- a/internal/cli/description_sync.go
+++ b/internal/cli/description_sync.go
@@ -1,113 +1,112 @@
 package cli
 
 import (
-    "fmt"
-    "strings"
+	"fmt"
+	"strings"
 
-    "codeberg.org/snonux/gitsyncer/internal/codeberg"
-    "codeberg.org/snonux/gitsyncer/internal/config"
-    "codeberg.org/snonux/gitsyncer/internal/github"
+	"codeberg.org/snonux/gitsyncer/internal/codeberg"
+	"codeberg.org/snonux/gitsyncer/internal/config"
+	"codeberg.org/snonux/gitsyncer/internal/github"
 )
 
 // syncRepoDescriptions ensures both platforms have the canonical description
 // Precedence: Codeberg > GitHub; if Codeberg empty and GitHub has one, use GitHub.
 // knownCBDesc and knownGHDesc can be empty; the function fetches as needed.
 func syncRepoDescriptions(cfg *config.Config, dryRun bool, repoName, knownCBDesc, knownGHDesc string, cache map[string]string) {
-    // Load orgs
-    ghOrg := cfg.FindGitHubOrg()
-    cbOrg := cfg.FindCodebergOrg()
+	// Load orgs
+	ghOrg := cfg.FindGitHubOrg()
+	cbOrg := cfg.FindCodebergOrg()
 
-    var ghClient *github.Client
-    var cbClient *codeberg.Client
-    if ghOrg != nil {
-        c := github.NewClient(ghOrg.GitHubToken, ghOrg.Name)
-        ghClient = &c
-    }
-    if cbOrg != nil {
-        c := codeberg.NewClient(cbOrg.Name, cbOrg.CodebergToken)
-        cbClient = &c
-    }
+	var ghClient *github.Client
+	var cbClient *codeberg.Client
+	if ghOrg != nil {
+		c := github.NewClient(ghOrg.GitHubToken, ghOrg.Name)
+		ghClient = &c
+	}
+	if cbOrg != nil {
+		c := codeberg.NewClient(cbOrg.Name, cbOrg.CodebergToken)
+		cbClient = &c
+	}
 
-    // Get current descriptions (use known if provided)
-    cbDesc := strings.TrimSpace(knownCBDesc)
-    ghDesc := strings.TrimSpace(knownGHDesc)
-    var cbExists, ghExists bool
+	// Get current descriptions (use known if provided)
+	cbDesc := strings.TrimSpace(knownCBDesc)
+	ghDesc := strings.TrimSpace(knownGHDesc)
+	var cbExists, ghExists bool
 
-    if cbDesc == "" && cbClient != nil {
-        if repo, exists, err := cbClient.GetRepo(repoName); err == nil {
-            cbExists = exists
-            if exists {
-                cbDesc = strings.TrimSpace(repo.Description)
-            }
-        } else {
-            fmt.Printf("  Warning: Codeberg repo lookup failed: %v\n", err)
-        }
-    } else if cbClient != nil {
-        cbExists = true
-    }
+	if cbDesc == "" && cbClient != nil {
+		if repo, exists, err := cbClient.GetRepo(repoName); err == nil {
+			cbExists = exists
+			if exists {
+				cbDesc = strings.TrimSpace(repo.Description)
+			}
+		} else {
+			fmt.Printf("  Warning: Codeberg repo lookup failed: %v\n", err)
+		}
+	} else if cbClient != nil {
+		cbExists = true
+	}
 
-    if ghClient != nil {
-        if ghDesc == "" || !ghExists {
-            if repo, exists, err := ghClient.GetRepo(repoName); err == nil {
-                ghExists = exists
-                if exists {
-                    ghDesc = strings.TrimSpace(repo.Description)
-                }
-            } else {
-                fmt.Printf("  Warning: GitHub repo lookup failed: %v\n", err)
-            }
-        }
-    }
+	if ghClient != nil {
+		if ghDesc == "" || !ghExists {
+			if repo, exists, err := ghClient.GetRepo(repoName); err == nil {
+				ghExists = exists
+				if exists {
+					ghDesc = strings.TrimSpace(repo.Description)
+				}
+			} else {
+				fmt.Printf("  Warning: GitHub repo lookup failed: %v\n", err)
+			}
+		}
+	}
 
-    // Determine canonical description
-    canonical := cbDesc
-    if canonical == "" {
-        canonical = ghDesc
-    }
-    canonical = strings.TrimSpace(canonical)
+	// Determine canonical description
+	canonical := cbDesc
+	if canonical == "" {
+		canonical = ghDesc
+	}
+	canonical = strings.TrimSpace(canonical)
 
-    // If nothing to sync, bail
-    if canonical == "" {
-        return
-    }
+	// If nothing to sync, bail
+	if canonical == "" {
+		return
+	}
 
-    // Update Codeberg if needed
-    if cbClient != nil && cbExists {
-        if cbDesc != canonical {
-            if dryRun {
-                fmt.Printf("  [DRY RUN] Would update Codeberg description for %s -> %q\n", repoName, canonical)
-            } else if cbClient.HasToken() {
-                if err := cbClient.UpdateRepoDescription(repoName, canonical); err != nil {
-                    fmt.Printf("  Warning: Failed to update Codeberg description: %v\n", err)
-                } else {
-                    fmt.Printf("  Updated Codeberg description for %s\n", repoName)
-                }
-            } else {
-                fmt.Println("  Warning: No Codeberg token; cannot update description")
-            }
-        }
-    }
+	// Update Codeberg if needed
+	if cbClient != nil && cbExists {
+		if cbDesc != canonical {
+			if dryRun {
+				fmt.Printf("  [DRY RUN] Would update Codeberg description for %s -> %q\n", repoName, canonical)
+			} else if cbClient.HasToken() {
+				if err := cbClient.UpdateRepoDescription(repoName, canonical); err != nil {
+					fmt.Printf("  Warning: Failed to update Codeberg description: %v\n", err)
+				} else {
+					fmt.Printf("  Updated Codeberg description for %s\n", repoName)
+				}
+			} else {
+				fmt.Println("  Warning: No Codeberg token; cannot update description")
+			}
+		}
+	}
 
-    // Update GitHub if needed
-    if ghClient != nil && ghExists {
-        if ghDesc != canonical {
-            if dryRun {
-                fmt.Printf("  [DRY RUN] Would update GitHub description for %s -> %q\n", repoName, canonical)
-            } else if ghClient.HasToken() {
-                if err := ghClient.UpdateRepoDescription(repoName, canonical); err != nil {
-                    fmt.Printf("  Warning: Failed to update GitHub description: %v\n", err)
-                } else {
-                    fmt.Printf("  Updated GitHub description for %s\n", repoName)
-                }
-            } else {
-                fmt.Println("  Warning: No GitHub token; cannot update description")
-            }
-        }
-    }
+	// Update GitHub if needed
+	if ghClient != nil && ghExists {
+		if ghDesc != canonical {
+			if dryRun {
+				fmt.Printf("  [DRY RUN] Would update GitHub description for %s -> %q\n", repoName, canonical)
+			} else if ghClient.HasToken() {
+				if err := ghClient.UpdateRepoDescription(repoName, canonical); err != nil {
+					fmt.Printf("  Warning: Failed to update GitHub description: %v\n", err)
+				} else {
+					fmt.Printf("  Updated GitHub description for %s\n", repoName)
+				}
+			} else {
+				fmt.Println("  Warning: No GitHub token; cannot update description")
+			}
+		}
+	}
 
-    // Update cache
-    if cache != nil {
-        cache[repoName] = canonical
-    }
+	// Update cache
+	if cache != nil {
+		cache[repoName] = canonical
+	}
 }
-
diff --git a/internal/cli/flags.go b/internal/cli/flags.go
index 43d9fa3..5c6914c 100644
--- a/internal/cli/flags.go
+++ b/internal/cli/flags.go
@@ -4,39 +4,39 @@ import (
 	"flag"
 	"os"
 	"path/filepath"
-	
+
 	"codeberg.org/snonux/gitsyncer/internal/state"
 )
 
 // Flags holds all command-line flag values
 type Flags struct {
-	VersionFlag        bool
-	ConfigPath         string
-	ListOrgs           bool
-	ListRepos          bool
-	SyncRepo           string
-	SyncAll            bool
-	SyncCodebergPublic bool
-	SyncGitHubPublic   bool
-	FullSync           bool
-	CreateGitHubRepos  bool
+	VersionFlag         bool
+	ConfigPath          string
+	ListOrgs            bool
+	ListRepos           bool
+	SyncRepo            string
+	SyncAll             bool
+	SyncCodebergPublic  bool
+	SyncGitHubPublic    bool
+	FullSync            bool
+	CreateGitHubRepos   bool
 	CreateCodebergRepos bool
-	DryRun             bool
-	WorkDir            string
-	TestGitHubToken    bool
-	Clean              bool
-	DeleteRepo         string
-	Backup             bool
-	Showcase           bool
-	Force              bool
-	BatchRun           bool
-	CheckReleases      bool
-	NoCheckReleases    bool
-	AutoCreateReleases bool
-	AIReleaseNotes     bool
-	UpdateReleases     bool
-	AITool             string
-	
+	DryRun              bool
+	WorkDir             string
+	TestGitHubToken     bool
+	Clean               bool
+	DeleteRepo          string
+	Backup              bool
+	Showcase            bool
+	Force               bool
+	BatchRun            bool
+	CheckReleases       bool
+	NoCheckReleases     bool
+	AutoCreateReleases  bool
+	AIReleaseNotes      bool
+	UpdateReleases      bool
+	AITool              string
+
 	// Internal fields for batch run state management (not set by flags)
 	BatchRunStateManager *state.Manager
 	BatchRunState        *state.State
@@ -45,7 +45,7 @@ type Flags struct {
 // ParseFlags parses command-line flags and returns the flags struct
 func ParseFlags() *Flags {
 	f := &Flags{}
-	
+
 	flag.BoolVar(&f.VersionFlag, "version", false, "print version information")
 	flag.BoolVar(&f.VersionFlag, "v", false, "print version information (short)")
 	flag.StringVar(&f.ConfigPath, "config", "", "path to configuration file")
@@ -65,17 +65,17 @@ func ParseFlags() *Flags {
 	flag.BoolVar(&f.Clean, "clean", false, "delete all repositories in work directory (with confirmation)")
 	flag.StringVar(&f.DeleteRepo, "delete-repo", "", "delete specified repository from all configured organizations (with confirmation)")
 	flag.BoolVar(&f.Backup, "backup", false, "enable syncing to backup locations")
-	flag.BoolVar(&f.Showcase, "showcase", false, "generate project showcase using Claude after syncing")
+	flag.BoolVar(&f.Showcase, "showcase", false, "generate project showcase using AI (amp by default) after syncing")
 	flag.BoolVar(&f.Force, "force", false, "force regeneration of cached data")
 	flag.BoolVar(&f.BatchRun, "batch-run", false, "enable --full and --showcase (runs only once per week)")
 	flag.BoolVar(&f.CheckReleases, "check-releases", false, "manually check for version tags without releases and create them (with confirmation)")
 	flag.BoolVar(&f.NoCheckReleases, "no-check-releases", false, "disable automatic release checking after sync operations")
 	flag.BoolVar(&f.AutoCreateReleases, "auto-create-releases", false, "automatically create releases without confirmation prompts")
-	flag.BoolVar(&f.AIReleaseNotes, "ai-release-notes", false, "generate release notes using Claude AI based on git diff")
+	flag.BoolVar(&f.AIReleaseNotes, "ai-release-notes", false, "generate release notes using AI (amp by default) based on git diff")
 	flag.BoolVar(&f.UpdateReleases, "update-releases", false, "update existing releases with new AI-generated notes")
-	
+
 	flag.Parse()
-	
+
 	// Set default WorkDir if not provided
 	if f.WorkDir == "" {
 		home, err := os.UserHomeDir()
@@ -86,7 +86,7 @@ func ParseFlags() *Flags {
 			f.WorkDir = ".gitsyncer-work"
 		}
 	}
-	
+
 	// Handle --full flag by enabling all sync operations
 	if f.FullSync {
 		f.SyncCodebergPublic = true
@@ -94,7 +94,7 @@ func ParseFlags() *Flags {
 		f.CreateGitHubRepos = true
 		f.CreateCodebergRepos = true
 	}
-	
+
 	// Handle --batch-run flag by enabling --full and --showcase
 	if f.BatchRun {
 		f.FullSync = true
@@ -105,6 +105,6 @@ func ParseFlags() *Flags {
 		f.CreateGitHubRepos = true
 		f.CreateCodebergRepos = true
 	}
-	
+
 	return f
-}
\ No newline at end of file
+}
diff --git a/internal/cli/handlers.go b/internal/cli/handlers.go
index 02df7ae..aa43a86 100644
--- a/internal/cli/handlers.go
+++ b/internal/cli/handlers.go
@@ -28,7 +28,7 @@ func HandleTestGitHubToken() int {
 		fmt.Println("Please set GITHUB_TOKEN environment variable or create ~/.gitsyncer_github_token file")
 		return 1
 	}
-	
+
 	// Test the token by checking a known repo
 	exists, err := client.RepoExists("gitsyncer")
 	if err != nil {
@@ -41,7 +41,7 @@ func HandleTestGitHubToken() int {
 		}
 		return 1
 	}
-	
+
 	fmt.Printf("SUCCESS: Token is valid! Repository check returned: %v\n", exists)
 	return 0
 }
@@ -54,7 +54,7 @@ func LoadConfig(configPath string) (*config.Config, error) {
 			return nil, fmt.Errorf("no configuration file found")
 		}
 	}
-	
+
 	fmt.Printf("Loaded configuration from: %s\n", configPath)
 	return config.Load(configPath)
 }
@@ -78,14 +78,14 @@ func findDefaultConfigPath() string {
 			return loc
 		}
 	}
-	
+
 	return ""
 }
 
 // ShowConfigHelp displays help for creating a configuration file
 func ShowConfigHelp() {
 	home, _ := os.UserHomeDir()
-	
+
 	fmt.Println("No configuration file found. Please create one of:")
 	fmt.Printf("  - ./gitsyncer.json\n")
 	fmt.Printf("  - %s/.config/gitsyncer/config.json\n", home)
@@ -135,7 +135,7 @@ func HandleListRepos(cfg *config.Config) int {
 // ShowUsage displays the usage information
 func ShowUsage(cfg *config.Config) {
 	fmt.Println("\ngitsyncer - Git repository synchronization tool")
-	fmt.Printf("Configured with %d organization(s) and %d repository(ies)\n", 
+	fmt.Printf("Configured with %d organization(s) and %d repository(ies)\n",
 		len(cfg.Organizations), len(cfg.Repositories))
 	fmt.Println("\nUsage:")
 	fmt.Println("  gitsyncer --sync <repo-name>        Sync a specific repository")
@@ -166,18 +166,18 @@ func HandleDeleteRepo(cfg *config.Config, repoName string) int {
 	}
 
 	fmt.Printf("\n⚠️  WARNING: This will permanently delete the repository '%s' from all configured organizations!\n\n", repoName)
-	
+
 	// Find organizations where the repo exists
 	var orgsWithRepo []struct {
 		org    config.Organization
 		exists bool
 		err    error
 	}
-	
+
 	for _, org := range cfg.Organizations {
 		var exists bool
 		var err error
-		
+
 		switch org.Host {
 		case "git@github.com":
 			client := github.NewClient(org.GitHubToken, org.Name)
@@ -189,14 +189,14 @@ func HandleDeleteRepo(cfg *config.Config, repoName string) int {
 			fmt.Printf("Skipping unsupported host: %s\n", org.Host)
 			continue
 		}
-		
+
 		orgsWithRepo = append(orgsWithRepo, struct {
 			org    config.Organization
 			exists bool
 			err    error
 		}{org, exists, err})
 	}
-	
+
 	// Show summary of where the repo exists
 	fmt.Println("Repository status:")
 	foundAny := false
@@ -210,36 +210,36 @@ func HandleDeleteRepo(cfg *config.Config, repoName string) int {
 			fmt.Printf("  ⬜ %s: Not found\n", info.org.GetGitURL())
 		}
 	}
-	
+
 	if !foundAny {
 		fmt.Printf("\nRepository '%s' not found in any configured organization.\n", repoName)
 		return 0
 	}
-	
+
 	// Confirm deletion
 	fmt.Printf("\nAre you sure you want to delete '%s' from the above organizations? This action cannot be undone!\n", repoName)
 	fmt.Print("Type 'yes' to confirm: ")
-	
+
 	reader := bufio.NewReader(os.Stdin)
 	confirmation, _ := reader.ReadString('\n')
 	confirmation = strings.TrimSpace(confirmation)
-	
+
 	if confirmation != "yes" {
 		fmt.Println("Deletion cancelled.")
 		return 0
 	}
-	
+
 	// Perform deletions
 	fmt.Println("\nDeleting repositories...")
 	hasError := false
-	
+
 	for _, info := range orgsWithRepo {
 		if !info.exists || info.err != nil {
 			continue
 		}
-		
+
 		fmt.Printf("  Deleting from %s... ", info.org.GetGitURL())
-		
+
 		var deleteErr error
 		switch info.org.Host {
 		case "git@github.com":
@@ -249,7 +249,7 @@ func HandleDeleteRepo(cfg *config.Config, repoName string) int {
 			client := codeberg.NewClient(info.org.Name, info.org.CodebergToken)
 			deleteErr = client.DeleteRepo(repoName)
 		}
-		
+
 		if deleteErr != nil {
 			fmt.Printf("FAILED: %v\n", deleteErr)
 			hasError = true
@@ -257,12 +257,12 @@ func HandleDeleteRepo(cfg *config.Config, repoName string) int {
 			fmt.Println("SUCCESS")
 		}
 	}
-	
+
 	if hasError {
 		fmt.Println("\n⚠️  Some deletions failed. Check the errors above.")
 		return 1
 	}
-	
+
 	fmt.Printf("\n✅ Repository '%s' has been successfully deleted from all organizations.\n", repoName)
 	return 0
-}
\ No newline at end of file
+}
diff --git a/internal/cli/release.go b/internal/cli/release.go
index 86cc5f9..e6dd057 100644
--- a/internal/cli/release.go
+++ b/internal/cli/release.go
@@ -29,7 +29,7 @@ func HandleCheckReleases(cfg *config.Config, flags *Flags) int {
 		fmt.Printf("Error reading work directory %s: %v\n", flags.WorkDir, err)
 		return 1
 	}
-	
+
 	var repositories []string
 	for _, entry := range entries {
 		if entry.IsDir() {
@@ -40,12 +40,12 @@ func HandleCheckReleases(cfg *config.Config, flags *Flags) int {
 			}
 		}
 	}
-	
+
 	if len(repositories) == 0 {
 		fmt.Println("No repositories found in work directory")
 		return 1
 	}
-	
+
 	fmt.Printf("Found %d repositories in work directory\n", len(repositories))
 	return HandleCheckReleasesForRepos(cfg, flags, repositories)
 }
@@ -60,23 +60,23 @@ func HandleCheckReleasesForRepo(cfg *config.Config, flags *Flags, repoName strin
 func HandleCheckReleasesForRepos(cfg *config.Config, flags *Flags, repositories []string) int {
 	releaseManager := release.NewManager(flags.WorkDir)
 	releaseManager.SetAITool(flags.AITool)
-	
+
 	// Load persistent AI release notes cache
 	cacheFile := filepath.Join(flags.WorkDir, ".gitsyncer-ai-release-notes-cache.json")
 	aiReleaseNotesCache := loadAIReleaseNotesCache(cacheFile)
 	initialCacheSize := len(aiReleaseNotesCache)
-	
+
 	// Track failed AI generations
 	failedAIGenerations := []string{}
-	
+
 	// Print summary at the end
 	defer func() {
 		if len(aiReleaseNotesCache) > initialCacheSize {
-			fmt.Printf("\nAI release notes cache updated: %d new entries added (total: %d entries)\n", 
+			fmt.Printf("\nAI release notes cache updated: %d new entries added (total: %d entries)\n",
 				len(aiReleaseNotesCache)-initialCacheSize, len(aiReleaseNotesCache))
 			fmt.Printf("Cache file: %s\n", cacheFile)
 		}
-		
+
 		if len(failedAIGenerations) > 0 {
 			fmt.Printf("\n⚠️  AI release notes generation failed for %d releases:\n", len(failedAIGenerations))
 			for _, failed := range failedAIGenerations {
@@ -86,12 +86,12 @@ func HandleCheckReleasesForRepos(cfg *config.Config, flags *Flags, repositories
 			fmt.Println("Run again to retry generation for these releases.")
 		}
 	}()
-	
+
 	// Set tokens from config with fallback to environment variables and files
 	githubOrg := cfg.FindGitHubOrg()
 	if githubOrg != nil {
 		fmt.Printf("Found GitHub org: %s\n", githubOrg.Name)
-		
+
 		// Try config token first, then fallback to env var and file
 		token := githubOrg.GitHubToken
 		if token == "" {
@@ -109,7 +109,7 @@ func HandleCheckReleasesForRepos(cfg *config.Config, flags *Flags, repositories
 				}
 			}
 		}
-		
+
 		if token != "" {
 			releaseManager.SetGitHubToken(token)
 		} else {
@@ -118,11 +118,11 @@ func HandleCheckReleasesForRepos(cfg *config.Config, flags *Flags, repositories
 	} else {
 		fmt.Println("No GitHub organization found in config")
 	}
-	
+
 	codebergOrg := cfg.FindCodebergOrg()
 	if codebergOrg != nil {
 		fmt.Printf("Found Codeberg org: %s\n", codebergOrg.Name)
-		
+
 		// Try config token first, then fallback to env var and file
 		token := codebergOrg.CodebergToken
 		if token == "" {
@@ -140,7 +140,7 @@ func HandleCheckReleasesForRepos(cfg *config.Config, flags *Flags, repositories
 				}
 			}
 		}
-		
+
 		if token != "" {
 			releaseManager.SetCodebergToken(token)
 			fmt.Printf("  Codeberg token loaded (length: %d)\n", len(token))
@@ -150,114 +150,114 @@ func HandleCheckReleasesForRepos(cfg *config.Config, flags *Flags, repositories
 	} else {
 		fmt.Println("No Codeberg organization found in config")
 	}
-	
-        // Process the specified repositories
-        for _, repoName := range repositories {
-            fmt.Printf("\nChecking releases for repository: %s\n", repoName)
-		
+
+	// Process the specified repositories
+	for _, repoName := range repositories {
+		fmt.Printf("\nChecking releases for repository: %s\n", repoName)
+
 		// Check if the repository is cloned locally
 		repoPath := filepath.Join(flags.WorkDir, repoName)
 		if _, err := os.Stat(repoPath); os.IsNotExist(err) {
 			fmt.Printf("  Repository not found locally at %s, skipping...\n", repoPath)
 			continue
 		}
-		
+
 		// Get local tags
 		localTags, err := releaseManager.GetLocalTags(repoPath)
 		if err != nil {
 			fmt.Printf("  Error getting local tags: %v\n", err)
 			continue
 		}
-		
+
 		if len(localTags) == 0 {
 			fmt.Println("  No version tags found")
 			continue
 		}
-		
-            fmt.Printf("  Found %d version tags: %s\n", len(localTags), strings.Join(localTags, ", "))
-            // Log configured skip rules for this repo, if any
-            if cfg.SkipReleases != nil {
-                if skipTags, ok := cfg.SkipReleases[repoName]; ok && len(skipTags) > 0 {
-                    fmt.Printf("  Config skip_releases for %s: %s\n", repoName, strings.Join(skipTags, ", "))
-                }
-            }
-		
+
+		fmt.Printf("  Found %d version tags: %s\n", len(localTags), strings.Join(localTags, ", "))
+		// Log configured skip rules for this repo, if any
+		if cfg.SkipReleases != nil {
+			if skipTags, ok := cfg.SkipReleases[repoName]; ok && len(skipTags) > 0 {
+				fmt.Printf("  Config skip_releases for %s: %s\n", repoName, strings.Join(skipTags, ", "))
+			}
+		}
+
 		// Check GitHub releases if GitHub is configured
 		var missingGitHub []string
 		githubOrg := cfg.FindGitHubOrg()
-            if githubOrg != nil && githubOrg.Name != "" {
-                githubReleases, err := releaseManager.GetGitHubReleases(githubOrg.Name, repoName)
-                if err != nil {
-                    fmt.Printf("  Error checking GitHub releases: %v\n", err)
-                } else {
-                    missingGitHub = releaseManager.FindMissingReleases(localTags, githubReleases)
-                    // Filter out tags that should be skipped per config
-                    if len(missingGitHub) > 0 {
-                        var filtered []string
-                        var skipped []string
-                        for _, t := range missingGitHub {
-                            if cfg.ShouldSkipRelease(repoName, t) {
-                                skipped = append(skipped, t)
-                            } else {
-                                filtered = append(filtered, t)
-                            }
-                        }
-                        if len(skipped) > 0 {
-                            fmt.Printf("  Skipping GitHub releases per config for tags: %s\n", strings.Join(skipped, ", "))
-                        }
-                        missingGitHub = filtered
-                        if len(missingGitHub) > 0 {
-                            fmt.Printf("  Missing GitHub releases: %s\n", strings.Join(missingGitHub, ", "))
-                        }
-                    }
-                }
-            }
-		
+		if githubOrg != nil && githubOrg.Name != "" {
+			githubReleases, err := releaseManager.GetGitHubReleases(githubOrg.Name, repoName)
+			if err != nil {
+				fmt.Printf("  Error checking GitHub releases: %v\n", err)
+			} else {
+				missingGitHub = releaseManager.FindMissingReleases(localTags, githubReleases)
+				// Filter out tags that should be skipped per config
+				if len(missingGitHub) > 0 {
+					var filtered []string
+					var skipped []string
+					for _, t := range missingGitHub {
+						if cfg.ShouldSkipRelease(repoName, t) {
+							skipped = append(skipped, t)
+						} else {
+							filtered = append(filtered, t)
+						}
+					}
+					if len(skipped) > 0 {
+						fmt.Printf("  Skipping GitHub releases per config for tags: %s\n", strings.Join(skipped, ", "))
+					}
+					missingGitHub = filtered
+					if len(missingGitHub) > 0 {
+						fmt.Printf("  Missing GitHub releases: %s\n", strings.Join(missingGitHub, ", "))
+					}
+				}
+			}
+		}
+
 		// Check Codeberg releases if Codeberg is configured
 		var missingCodeberg []string
 		codebergOrg := cfg.FindCodebergOrg()
-            if codebergOrg != nil && codebergOrg.Name != "" {
-                codebergReleases, err := releaseManager.GetCodebergReleases(codebergOrg.Name, repoName)
-                if err != nil {
-                    fmt.Printf("  Error checking Codeberg releases: %v\n", err)
-                } else {
-                    missingCodeberg = releaseManager.FindMissingReleases(localTags, codebergReleases)
-                    // Filter out tags that should be skipped per config
-                    if len(missingCodeberg) > 0 {
-                        var filtered []string
-                        var skipped []string
-                        for _, t := range missingCodeberg {
-                            if cfg.ShouldSkipRelease(repoName, t) {
-                                skipped = append(skipped, t)
-                            } else {
-                                filtered = append(filtered, t)
-                            }
-                        }
-                        if len(skipped) > 0 {
-                            fmt.Printf("  Skipping Codeberg releases per config for tags: %s\n", strings.Join(skipped, ", "))
-                        }
-                        missingCodeberg = filtered
-                        if len(missingCodeberg) > 0 {
-                            fmt.Printf("  Missing Codeberg releases: %s\n", strings.Join(missingCodeberg, ", "))
-                        }
-                    }
-                }
-            }
-		
+		if codebergOrg != nil && codebergOrg.Name != "" {
+			codebergReleases, err := releaseManager.GetCodebergReleases(codebergOrg.Name, repoName)
+			if err != nil {
+				fmt.Printf("  Error checking Codeberg releases: %v\n", err)
+			} else {
+				missingCodeberg = releaseManager.FindMissingReleases(localTags, codebergReleases)
+				// Filter out tags that should be skipped per config
+				if len(missingCodeberg) > 0 {
+					var filtered []string
+					var skipped []string
+					for _, t := range missingCodeberg {
+						if cfg.ShouldSkipRelease(repoName, t) {
+							skipped = append(skipped, t)
+						} else {
+							filtered = append(filtered, t)
+						}
+					}
+					if len(skipped) > 0 {
+						fmt.Printf("  Skipping Codeberg releases per config for tags: %s\n", strings.Join(skipped, ", "))
+					}
+					missingCodeberg = filtered
+					if len(missingCodeberg) > 0 {
+						fmt.Printf("  Missing Codeberg releases: %s\n", strings.Join(missingCodeberg, ", "))
+					}
+				}
+			}
+		}
+
 		// Create missing releases with confirmation
-            if len(missingGitHub) > 0 && githubOrg != nil {
-                for _, tag := range missingGitHub {
-                    // Skip if configured to skip this repo/tag
-                    if cfg.ShouldSkipRelease(repoName, tag) {
-                        fmt.Printf("  Skipping GitHub release for %s:%s per config skip_releases\n", repoName, tag)
-                        continue
-                    }
+		if len(missingGitHub) > 0 && githubOrg != nil {
+			for _, tag := range missingGitHub {
+				// Skip if configured to skip this repo/tag
+				if cfg.ShouldSkipRelease(repoName, tag) {
+					fmt.Printf("  Skipping GitHub release for %s:%s per config skip_releases\n", repoName, tag)
+					continue
+				}
 				// Get commits for this tag
 				commits, err := releaseManager.GetCommitsSinceTag(repoPath, "", tag)
 				if err != nil {
 					commits = []string{}
 				}
-				
+
 				// Generate release notes
 				var releaseNotes string
 				if flags.AIReleaseNotes {
@@ -295,16 +295,16 @@ func HandleCheckReleasesForRepos(cfg *config.Config, flags *Flags, repositories
 				} else {
 					releaseNotes = releaseManager.GenerateReleaseNotes(repoPath, tag, localTags)
 				}
-				
+
 				// Print release notes to stdout
 				fmt.Printf("\n%s\n", strings.Repeat("=", 70))
 				fmt.Printf("Release Notes for %s/%s tag %s:\n", githubOrg.Name, repoName, tag)
 				fmt.Printf("%s\n", strings.Repeat("-", 70))
 				fmt.Println(releaseNotes)
 				fmt.Printf("%s\n\n", strings.Repeat("=", 70))
-				
+
 				msg := fmt.Sprintf("Create GitHub release for %s/%s tag %s?", githubOrg.Name, repoName, tag)
-				
+
 				// Check if auto-create is enabled
 				createRelease := false
 				if flags.AutoCreateReleases {
@@ -313,7 +313,7 @@ func HandleCheckReleasesForRepos(cfg *config.Config, flags *Flags, repositories
 				} else {
 					createRelease = release.PromptConfirmation(msg)
 				}
-				
+
 				if createRelease {
 					if err := releaseManager.CreateGitHubRelease(githubOrg.Name, repoName, tag, releaseNotes); err != nil {
 						fmt.Printf("  Error creating GitHub release: %v\n", err)
@@ -323,24 +323,24 @@ func HandleCheckReleasesForRepos(cfg *config.Config, flags *Flags, repositories
 				}
 			}
 		}
-		
-            if len(missingCodeberg) > 0 && codebergOrg != nil {
-                // Ensure Releases feature is enabled on Codeberg before creating releases
-                if err := releaseManager.EnsureCodebergReleasesEnabled(codebergOrg.Name, repoName); err != nil {
-                    fmt.Printf("  Warning: Could not ensure Codeberg releases are enabled: %v\n", err)
-                }
-                for _, tag := range missingCodeberg {
-                    // Skip if configured to skip this repo/tag
-                    if cfg.ShouldSkipRelease(repoName, tag) {
-                        fmt.Printf("  Skipping Codeberg release for %s:%s per config skip_releases\n", repoName, tag)
-                        continue
-                    }
+
+		if len(missingCodeberg) > 0 && codebergOrg != nil {
+			// Ensure Releases feature is enabled on Codeberg before creating releases
+			if err := releaseManager.EnsureCodebergReleasesEnabled(codebergOrg.Name, repoName); err != nil {
+				fmt.Printf("  Warning: Could not ensure Codeberg releases are enabled: %v\n", err)
+			}
+			for _, tag := range missingCodeberg {
+				// Skip if configured to skip this repo/tag
+				if cfg.ShouldSkipRelease(repoName, tag) {
+					fmt.Printf("  Skipping Codeberg release for %s:%s per config skip_releases\n", repoName, tag)
+					continue
+				}
 				// Get commits for this tag
 				commits, err := releaseManager.GetCommitsSinceTag(repoPath, "", tag)
 				if err != nil {
 					commits = []string{}
 				}
-				
+
 				// Generate release notes
 				var releaseNotes string
 				if flags.AIReleaseNotes {
@@ -378,16 +378,16 @@ func HandleCheckReleasesForRepos(cfg *config.Config, flags *Flags, repositories
 				} else {
 					releaseNotes = releaseManager.GenerateReleaseNotes(repoPath, tag, localTags)
 				}
-				
+
 				// Print release notes to stdout
 				fmt.Printf("\n%s\n", strings.Repeat("=", 70))
 				fmt.Printf("Release Notes for %s/%s tag %s:\n", codebergOrg.Name, repoName, tag)
 				fmt.Printf("%s\n", strings.Repeat("-", 70))
 				fmt.Println(releaseNotes)
 				fmt.Printf("%s\n\n", strings.Repeat("=", 70))
-				
+
 				msg := fmt.Sprintf("Create Codeberg release for %s/%s tag %s?", codebergOrg.Name, repoName, tag)
-				
+
 				// Check if auto-create is enabled
 				createRelease := false
 				if flags.AutoCreateReleases {
@@ -396,7 +396,7 @@ func Han