feat(cli): resolve org/repo names, improve validation, fix single-group export

metrics: accept owner/name format in --repo flag by resolving it to a DB
ID via RepoRepository.GetByFullName; improve error message; show repo
name alongside ID in output. Remove unused ErrNotImplemented sentinel.

validate: replace static success stubs with real per-group checks for
repository name format (org/repo), duplicate targets, and duplicate file
destinations; report individual failures instead of always printing ✓.

db-export: implement proper single-group export using ExportGroup instead
of the previous stub that exported everything and ignored the --group
filter. Wrap result in a single-group Config for YAML output.

state: remove placeholder comment from ParseBranchName; delegates to
parseSyncBranchName as intended.

Author: mrz1836

internal/cli/analytics.go

@@ -1,14 +1,9 @@
 package cli
 
 import (
-	"errors"
-
 	"github.com/spf13/cobra"
 )
 
-// ErrNotImplemented is returned for features not yet implemented
-var ErrNotImplemented = errors.New("feature not yet implemented")
-
 // newAnalyticsCmd creates the analytics command group
 func newAnalyticsCmd() *cobra.Command {
 	cmd := &cobra.Command{

internal/cli/db_export.go

@@ -9,6 +9,7 @@ import (
 	"gopkg.in/yaml.v3"
 	"gorm.io/gorm/logger"
 
+	"github.com/mrz1836/go-broadcast/internal/config"
 	"github.com/mrz1836/go-broadcast/internal/db"
 	"github.com/mrz1836/go-broadcast/internal/output"
 )
@@ -108,27 +109,32 @@ func runDBExport(cmd *cobra.Command, _ []string) error {
 	}
 
 	// Export configuration
-	output.Info(fmt.Sprintf("Exporting configuration: %s", configExternalID))
-	cfg, err := converter.ExportConfig(ctx, configExternalID)
-	if err != nil {
-		return fmt.Errorf("export failed: %w", err)
-	}
-
-	// Filter to single group if requested
+	var cfg *config.Config
 	if dbExportGroup != "" {
-		output.Info(fmt.Sprintf("Filtering to group: %s", dbExportGroup))
-		var filteredGroups []db.Group
-		for _, group := range cfg.Groups {
-			if group.ID == dbExportGroup {
-				// We need to export just this one group
-				// For now, keep all groups and let user extract
-				// In future, could add group-only export
-				break
-			}
+		// Export single group
+		output.Info(fmt.Sprintf("Exporting group: %s", dbExportGroup))
+
+		var dbCfg db.Config
+		if dbErr := database.DB().Where("external_id = ?", configExternalID).First(&dbCfg).Error; dbErr != nil {
+			return fmt.Errorf("failed to find config: %w", dbErr)
 		}
-		if len(filteredGroups) == 0 {
-			// Keep all groups for now (ExportGroup could be used for single group)
-			output.Warn("Note: Full config exported. Use YAML tools to extract specific group.")
+
+		group, gErr := converter.ExportGroup(ctx, dbCfg.ID, dbExportGroup)
+		if gErr != nil {
+			return fmt.Errorf("failed to export group %q: %w", dbExportGroup, gErr)
+		}
+
+		cfg = &config.Config{
+			Version: 1,
+			Groups:  []config.Group{*group},
+		}
+	} else {
+		// Export full config
+		output.Info(fmt.Sprintf("Exporting configuration: %s", configExternalID))
+		var eErr error
+		cfg, eErr = converter.ExportConfig(ctx, configExternalID)
+		if eErr != nil {
+			return fmt.Errorf("export failed: %w", eErr)
 		}
 	}
 

internal/cli/db_import_export_test.go

@@ -508,3 +508,124 @@ func TestDBImportReferenceResolution(t *testing.T) {
 	assert.Contains(t, exportedTarget.FileListRefs, "common-files")
 	assert.Contains(t, exportedTarget.DirectoryListRefs, "common-dirs")
 }
+
+// TestDBExportSingleGroup tests exporting a single group using ExportGroup
+func TestDBExportSingleGroup(t *testing.T) {
+	tmpDir := t.TempDir()
+	testDBPath := filepath.Join(tmpDir, "test.db")
+
+	// Initialize database
+	database, err := db.Open(db.OpenOptions{
+		Path:        testDBPath,
+		LogLevel:    logger.Silent,
+		AutoMigrate: true,
+	})
+	require.NoError(t, err)
+	defer func() { _ = database.Close() }()
+
+	ctx := context.Background()
+	converter := db.NewConverter(database.DB())
+
+	// Create multi-group config
+	testConfig := &config.Config{
+		Version: 1,
+		Name:    "multi-group",
+		ID:      "multi-cfg",
+		Groups: []config.Group{
+			{
+				Name: "Group Alpha",
+				ID:   "group-alpha",
+				Source: config.SourceConfig{
+					Repo:   "mrz1836/source",
+					Branch: "main",
+				},
+				Targets: []config.TargetConfig{
+					{Repo: "mrz1836/target1"},
+				},
+			},
+			{
+				Name: "Group Beta",
+				ID:   "group-beta",
+				Source: config.SourceConfig{
+					Repo:   "mrz1836/source2",
+					Branch: "main",
+				},
+				Targets: []config.TargetConfig{
+					{Repo: "mrz1836/target2"},
+					{Repo: "mrz1836/target3"},
+				},
+			},
+		},
+	}
+
+	// Import the multi-group config
+	dbCfg, err := converter.ImportConfig(ctx, testConfig)
+	require.NoError(t, err)
+
+	// Export single group
+	group, err := converter.ExportGroup(ctx, dbCfg.ID, "group-beta")
+	require.NoError(t, err)
+
+	// Verify only the requested group was exported
+	assert.Equal(t, "Group Beta", group.Name)
+	assert.Equal(t, "group-beta", group.ID)
+	assert.Len(t, group.Targets, 2)
+	assert.Equal(t, "mrz1836/target2", group.Targets[0].Repo)
+	assert.Equal(t, "mrz1836/target3", group.Targets[1].Repo)
+
+	// Verify the exported group can be wrapped in a config and marshaled to YAML
+	cfg := &config.Config{
+		Version: 1,
+		Groups:  []config.Group{*group},
+	}
+	yamlData, err := yaml.Marshal(cfg)
+	require.NoError(t, err)
+	assert.Contains(t, string(yamlData), "group-beta")
+	assert.NotContains(t, string(yamlData), "group-alpha")
+}
+
+// TestDBExportSingleGroup_NotFound tests error when exporting a nonexistent group
+func TestDBExportSingleGroup_NotFound(t *testing.T) {
+	tmpDir := t.TempDir()
+	testDBPath := filepath.Join(tmpDir, "test.db")
+
+	// Initialize database
+	database, err := db.Open(db.OpenOptions{
+		Path:        testDBPath,
+		LogLevel:    logger.Silent,
+		AutoMigrate: true,
+	})
+	require.NoError(t, err)
+	defer func() { _ = database.Close() }()
+
+	ctx := context.Background()
+	converter := db.NewConverter(database.DB())
+
+	// Import a config
+	testConfig := &config.Config{
+		Version: 1,
+		Name:    "test",
+		ID:      "test-cfg",
+		Groups: []config.Group{
+			{
+				Name: "Existing Group",
+				ID:   "existing",
+				Source: config.SourceConfig{
+					Repo:   "mrz1836/source",
+					Branch: "main",
+				},
+				Targets: []config.TargetConfig{
+					{Repo: "mrz1836/target1"},
+				},
+			},
+		},
+	}
+
+	dbCfg, err := converter.ImportConfig(ctx, testConfig)
+	require.NoError(t, err)
+
+	// Try to export nonexistent group
+	_, err = converter.ExportGroup(ctx, dbCfg.ID, "nonexistent")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "not found")
+}

internal/cli/metrics.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/spf13/cobra"
+	"gorm.io/gorm"
 
 	"github.com/mrz1836/go-broadcast/internal/db"
 )
@@ -104,7 +105,7 @@ func runMetrics(cmd *cobra.Command, args []string) error {
 	case runID != "":
 		return showRunDetails(ctx, syncRepo, runID, jsonOut)
 	case repo != "":
-		return showRepoHistory(ctx, syncRepo, repo, jsonOut)
+		return showRepoHistory(ctx, syncRepo, database.DB(), repo, jsonOut)
 	case last != "":
 		return showRecentRuns(ctx, syncRepo, last, jsonOut)
 	default:
@@ -200,18 +201,21 @@ func showRecentRuns(ctx context.Context, repo db.BroadcastSyncRepo, period strin
 }
 
 // showRepoHistory displays sync history for a specific repository
-func showRepoHistory(ctx context.Context, repo db.BroadcastSyncRepo, repoName string, jsonOut bool) error {
-	// Parse repo name to get repo ID
-	// For now, we need to query the repo by name
-	// This requires a helper function or we accept repo ID directly
-	// Let's accept both formats: ID or owner/name
-
+func showRepoHistory(ctx context.Context, repo db.BroadcastSyncRepo, gormDB *gorm.DB, repoName string, jsonOut bool) error {
 	// Try to parse as uint first (repo ID)
 	var repoID uint
 	if _, err := fmt.Sscanf(repoName, "%d", &repoID); err != nil {
-		// Not a number, try to resolve from name
-		// For now, return an error asking for ID
-		return fmt.Errorf("repo lookup by name not yet implemented, please use repo ID (e.g., --repo 5)") //nolint:err113 // user-facing CLI error
+		// Try to resolve "org/repo" format to DB ID
+		parts := strings.SplitN(repoName, "/", 2)
+		if len(parts) != 2 {
+			return fmt.Errorf("invalid repo format %q: use numeric ID or owner/name (e.g., --repo mrz1836/go-broadcast)", repoName) //nolint:err113 // user-facing CLI error
+		}
+		repoRepo := db.NewRepoRepository(gormDB)
+		dbRepo, lookupErr := repoRepo.GetByFullName(ctx, parts[0], parts[1])
+		if lookupErr != nil {
+			return fmt.Errorf("repo %q not found in database: %w", repoName, lookupErr)
+		}
+		repoID = dbRepo.ID
 	}
 
 	runs, err := repo.ListSyncRunsByRepo(ctx, repoID, 100)
@@ -225,7 +229,7 @@ func showRepoHistory(ctx context.Context, repo db.BroadcastSyncRepo, repoName st
 
 	// Human-readable output
 	//nolint:forbidigo // CLI output requires fmt.Printf for formatting
-	fmt.Printf("🔍 Sync History for Repo ID %d\n", repoID)
+	fmt.Printf("🔍 Sync History for Repo %s (ID %d)\n", repoName, repoID)
 	//nolint:forbidigo // CLI output requires fmt.Printf for formatting
 	fmt.Println(strings.Repeat("─", 100))
 

internal/cli/metrics_test.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"context"
 	"testing"
 	"time"
 
@@ -176,6 +177,17 @@ func TestMetricsFlagsThreadSafety(t *testing.T) {
 	})
 }
 
+// TestShowRepoHistory_InvalidFormat tests that invalid repo format gives a clear error
+func TestShowRepoHistory_InvalidFormat(t *testing.T) {
+	t.Run("no slash in name returns error", func(t *testing.T) {
+		// A string with no slash and not a number should fail
+		err := showRepoHistory(context.Background(), nil, nil, "not-a-repo", false)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "invalid repo format")
+		assert.Contains(t, err.Error(), "owner/name")
+	})
+}
+
 // TestMetricsCommandFlags tests metrics command flag initialization
 func TestMetricsCommandFlags(t *testing.T) {
 	t.Run("command has expected flags", func(t *testing.T) {

internal/cli/validate.go

@@ -145,13 +145,50 @@ func runValidateWithFlags(flags *Flags, cmd *cobra.Command) error {
 	output.Info("")
 	output.Info(fmt.Sprintf("Total file mappings: %d", totalFiles))
 
-	// Additional validation checks (future implementation)
+	// Additional validation checks — run lightweight per-check validation and report individually
 	output.Info("")
 	output.Info("Additional checks:")
-	output.Success("  ✓ Repository name format")
-	output.Success("  ✓ File paths")
-	output.Success("  ✓ No duplicate targets")
-	output.Success("  ✓ No duplicate file destinations")
+
+	allPassed := true
+	for _, group := range groups {
+		// Check repo name format (org/repo)
+		for _, target := range group.Targets {
+			if !strings.Contains(target.Repo, "/") {
+				output.Error(fmt.Sprintf("  ✗ Repository name format: %s (expected org/repo)", target.Repo))
+				allPassed = false
+			}
+		}
+
+		// Check for duplicate targets
+		seen := make(map[string]bool)
+		for _, target := range group.Targets {
+			lower := strings.ToLower(target.Repo)
+			if seen[lower] {
+				output.Error(fmt.Sprintf("  ✗ Duplicate target: %s", target.Repo))
+				allPassed = false
+			}
+			seen[lower] = true
+		}
+
+		// Check for duplicate file destinations
+		for _, target := range group.Targets {
+			destSeen := make(map[string]bool)
+			for _, f := range target.Files {
+				if destSeen[f.Dest] {
+					output.Error(fmt.Sprintf("  ✗ Duplicate file destination in %s: %s", target.Repo, f.Dest))
+					allPassed = false
+				}
+				destSeen[f.Dest] = true
+			}
+		}
+	}
+
+	if allPassed {
+		output.Success("  ✓ Repository name format")
+		output.Success("  ✓ File paths")
+		output.Success("  ✓ No duplicate targets")
+		output.Success("  ✓ No duplicate file destinations")
+	}
 
 	// Get command flags
 	skipRemoteChecks, _ := cmd.Flags().GetBool("skip-remote-checks")

internal/state/discovery.go

@@ -511,10 +511,9 @@ func (d *discoveryService) DiscoverTargetState(ctx context.Context, repo, branch
 	return targetState, nil
 }
 
-// ParseBranchName parses a branch name to extract sync metadata
+// ParseBranchName parses a branch name to extract sync metadata.
+// Delegates to parseSyncBranchName in branch.go.
 func (d *discoveryService) ParseBranchName(name string) (*BranchMetadata, error) {
-	// This will be implemented in branch.go
-	// For now, return a placeholder
 	return parseSyncBranchName(name)
 }