fix(.kbcignore): address Copilot review comments on branch ignore (PSGO-198)

- Fix correctness bug: branch names containing "/" (e.g. "branch/feature/foo")
  were split into 3 parts and misrouted to the config-row case; now handled via
  HasPrefix("branch/") guard before the generic split
- Add NullIgnoredBranchStates() to registry: single-pass over All() to null
  local+remote state for every ignored branch and all its configs/rows, avoiding
  repeated O(n²) ConfigsFrom/ConfigRowsFrom sorts in nested loops
- Replace triple-nested loops in push and pull operations with a call to
  NullIgnoredBranchStates(), eliminating the duplication between the two callers
- Add tests: branch-with-slash correctness test, NullIgnoredBranchStates unit test

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Matovidlo

internal/pkg/project/ignore/file_test.go

@@ -29,6 +29,16 @@ func Test_loadFile(t *testing.T) {
 	assert.Equal(t, "keboola.bar/678/34\nkeboola.foo/345", file.rawStringPattern)
 }
 
+func newTestRegistryWithSlashBranch(t *testing.T) *registry.Registry {
+	t.Helper()
+	r := registry.New(knownpaths.NewNop(t.Context()), naming.NewRegistry(), model.NewComponentsMap(nil), model.SortByPath)
+	require.NoError(t, r.Set(&model.BranchState{
+		BranchManifest: &model.BranchManifest{BranchKey: model.BranchKey{ID: 789}},
+		Local:          &model.Branch{Name: "feature/foo"},
+	}))
+	return r
+}
+
 func newTestRegistry(t *testing.T) *registry.Registry {
 	t.Helper()
 

internal/pkg/project/ignore/ignore.go

@@ -36,18 +36,19 @@ func (f *File) parseIgnoredPatterns() []string {
 
 // applyIgnorePattern applies a single ignore pattern, marking the appropriate config or row as ignored.
 func (f *File) applyIgnorePattern(ignoreConfig string) error {
-	parts := strings.Split(ignoreConfig, "/")
+	// Branch pattern: "branch/<name>" — name may itself contain "/".
+	if strings.HasPrefix(ignoreConfig, "branch/") {
+		branchName := strings.TrimPrefix(ignoreConfig, "branch/")
+		f.state.IgnoreBranch(branchName)
+		return nil
+	}
 
+	parts := strings.Split(ignoreConfig, "/")
 	switch len(parts) {
 	case 2:
-		if parts[0] == "branch" {
-			// Ignore entire branch by name.
-			f.state.IgnoreBranch(parts[1])
-		} else {
-			// Ignore config by componentID/configID.
-			configID, componentID := parts[1], parts[0]
-			f.state.IgnoreConfig(configID, componentID)
-		}
+		// Ignore config by componentID/configID.
+		configID, componentID := parts[1], parts[0]
+		f.state.IgnoreConfig(configID, componentID)
 	case 3:
 		// Ignore specific config row.
 		configID, rowID := parts[1], parts[2]

internal/pkg/project/ignore/ignore_test.go

@@ -50,6 +50,27 @@ func TestFile_IgnoreConfigsOrRows_Branch(t *testing.T) {
 	assert.Equal(t, "123", ignored[0].ID.String())
 }
 
+func TestFile_IgnoreConfigsOrRows_BranchWithSlashInName(t *testing.T) {
+	t.Parallel()
+
+	ctx := t.Context()
+	r := newTestRegistryWithSlashBranch(t)
+	fs := aferofs.NewMemoryFs()
+
+	require.NoError(t, fs.WriteFile(ctx, filesystem.NewRawFile(`foo/bar1`, "branch/feature/foo")))
+
+	file, err := LoadFile(ctx, fs, r, "foo/bar1")
+	require.NoError(t, err)
+
+	require.NoError(t, file.IgnoreConfigsOrRows())
+
+	// Branch "feature/foo" should be ignored, not misidentified as a config-row pattern.
+	ignored := r.IgnoredBranches()
+	require.Len(t, ignored, 1)
+	assert.Equal(t, "789", ignored[0].ID.String())
+	assert.Empty(t, r.IgnoredConfigRows())
+}
+
 func Test_applyIgnoredPatterns(t *testing.T) {
 	t.Parallel()
 	projectState := newTestRegistry(t)
@@ -109,6 +130,13 @@ func Test_applyIgnoredPatterns(t *testing.T) {
 			},
 			wantErr: assert.NoError,
 		},
+		{
+			name: "branch pattern with slash in name",
+			args: args{
+				pattern: "branch/feature/foo",
+			},
+			wantErr: assert.NoError,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

internal/pkg/state/registry/registry.go

@@ -167,6 +167,42 @@ func (s *Registry) IgnoredBranches() (branches []*model.BranchState) {
 	return branches
 }
 
+// NullIgnoredBranchStates nulls local+remote state for every ignored branch and for all
+// configs/rows belonging to those branches, using a single pass over All() to avoid
+// repeated sorts.
+func (s *Registry) NullIgnoredBranchStates() {
+	ignored := s.IgnoredBranches()
+	if len(ignored) == 0 {
+		return
+	}
+
+	// Build set of ignored branch keys for O(1) lookup.
+	ignoredKeys := make(map[model.BranchKey]struct{}, len(ignored))
+	for _, b := range ignored {
+		ignoredKeys[b.BranchKey] = struct{}{}
+	}
+
+	for _, obj := range s.All() {
+		switch v := obj.(type) {
+		case *model.BranchState:
+			if _, ok := ignoredKeys[v.BranchKey]; ok {
+				v.SetLocalState(nil)
+				v.SetRemoteState(nil)
+			}
+		case *model.ConfigState:
+			if _, ok := ignoredKeys[model.BranchKey{ID: v.BranchID}]; ok {
+				v.SetLocalState(nil)
+				v.SetRemoteState(nil)
+			}
+		case *model.ConfigRowState:
+			if _, ok := ignoredKeys[model.BranchKey{ID: v.BranchID}]; ok {
+				v.SetLocalState(nil)
+				v.SetRemoteState(nil)
+			}
+		}
+	}
+}
+
 func (s *Registry) IgnoreConfig(ignoreID string, componentID string) {
 	for _, object := range s.All() {
 		if v, ok := object.(*model.ConfigState); ok {

internal/pkg/state/registry/registry_test.go

@@ -228,6 +228,25 @@ func TestRegistry_GetByPath(t *testing.T) {
 	assert.True(t, found)
 }
 
+func TestNullIgnoredBranchStates(t *testing.T) {
+	t.Parallel()
+	s := newTestState(t, knownpaths.NewNop(t.Context()))
+
+	// Initially all 6 objects (2 branches, 2 configs, 2 rows) are present.
+	assert.Len(t, s.All(), 6)
+
+	// Ignore the "Main" branch (ID 123).
+	s.IgnoreBranch("Main")
+	s.NullIgnoredBranchStates()
+
+	// Branch 123, its 2 configs, and 2 config rows are now invisible (both states nil).
+	// Only branch 567 remains.
+	assert.Len(t, s.All(), 1)
+	assert.Equal(t, BranchKey{ID: 567}, s.Branches()[0].BranchKey)
+	assert.Empty(t, s.Configs())
+	assert.Empty(t, s.ConfigRows())
+}
+
 func TestIgnoreBranch(t *testing.T) {
 	t.Parallel()
 	s := newTestState(t, knownpaths.NewNop(t.Context()))

pkg/lib/operation/project/sync/pull/operation.go

@@ -166,16 +166,5 @@ func ignoreBranchesConfigsAndRows(projectState *project.State) {
 	}
 
 	// Null both states for ignored branches so they are invisible to the diff.
-	for _, branch := range projectState.IgnoredBranches() {
-		branch.SetLocalState(nil)
-		branch.SetRemoteState(nil)
-		for _, config := range projectState.ConfigsFrom(branch.BranchKey) {
-			config.SetLocalState(nil)
-			config.SetRemoteState(nil)
-			for _, row := range projectState.ConfigRowsFrom(config.ConfigKey) {
-				row.SetLocalState(nil)
-				row.SetRemoteState(nil)
-			}
-		}
-	}
+	projectState.NullIgnoredBranchStates()
 }

pkg/lib/operation/project/sync/push/operation.go

@@ -76,18 +76,7 @@ func Run(ctx context.Context, projectState *project.State, o Options, d dependen
 		}
 
 		// Make ignored branches invisible to the push diff.
-		for _, branch := range projectState.IgnoredBranches() {
-			branch.SetLocalState(nil)
-			branch.SetRemoteState(nil)
-			for _, config := range projectState.ConfigsFrom(branch.BranchKey) {
-				config.SetLocalState(nil)
-				config.SetRemoteState(nil)
-				for _, row := range projectState.ConfigRowsFrom(config.ConfigKey) {
-					row.SetLocalState(nil)
-					row.SetRemoteState(nil)
-				}
-			}
-		}
+		projectState.NullIgnoredBranchStates()
 	}
 
 	// Diff