coder/agent/agentgit/pathstore.go

package agentgit

import (
	"slices"
	"sync"

	"github.com/google/uuid"
)

// PathStore tracks which file paths each chat has touched.
// It is safe for concurrent use.
type PathStore struct {
	mu          sync.RWMutex
	chatPaths   map[uuid.UUID]map[string]struct{}
	subscribers map[uuid.UUID][]chan<- struct{}
}

// NewPathStore creates a new PathStore.
func NewPathStore() *PathStore {
	return &PathStore{
		chatPaths:   make(map[uuid.UUID]map[string]struct{}),
		subscribers: make(map[uuid.UUID][]chan<- struct{}),
	}
}

// AddPaths adds paths to every chat in chatIDs and notifies
// their subscribers. Zero-value UUIDs are silently skipped.
func (ps *PathStore) AddPaths(chatIDs []uuid.UUID, paths []string) {
	affected := make([]uuid.UUID, 0, len(chatIDs))
	for _, id := range chatIDs {
		if id != uuid.Nil {
			affected = append(affected, id)
		}
	}
	if len(affected) == 0 {
		return
	}

	ps.mu.Lock()
	for _, id := range affected {
		m, ok := ps.chatPaths[id]
		if !ok {
			m = make(map[string]struct{})
			ps.chatPaths[id] = m
		}
		for _, p := range paths {
			m[p] = struct{}{}
		}
	}
	ps.mu.Unlock()

	ps.notifySubscribers(affected)
}

// Notify sends a signal to all subscribers of the given chat IDs
// without adding any paths. Zero-value UUIDs are silently skipped.
func (ps *PathStore) Notify(chatIDs []uuid.UUID) {
	affected := make([]uuid.UUID, 0, len(chatIDs))
	for _, id := range chatIDs {
		if id != uuid.Nil {
			affected = append(affected, id)
		}
	}
	if len(affected) == 0 {
		return
	}
	ps.notifySubscribers(affected)
}

// notifySubscribers sends a non-blocking signal to all subscriber
// channels for the given chat IDs.
func (ps *PathStore) notifySubscribers(chatIDs []uuid.UUID) {
	ps.mu.RLock()
	toNotify := make([]chan<- struct{}, 0)
	for _, id := range chatIDs {
		toNotify = append(toNotify, ps.subscribers[id]...)
	}
	ps.mu.RUnlock()

	for _, ch := range toNotify {
		select {
		case ch <- struct{}{}:
		default:
		}
	}
}

// GetPaths returns all paths tracked for a chat, deduplicated
// and sorted lexicographically.
func (ps *PathStore) GetPaths(chatID uuid.UUID) []string {
	ps.mu.RLock()
	defer ps.mu.RUnlock()

	m := ps.chatPaths[chatID]
	if len(m) == 0 {
		return nil
	}
	out := make([]string, 0, len(m))
	for p := range m {
		out = append(out, p)
	}
	slices.Sort(out)
	return out
}

// Len returns the number of chat IDs that have tracked paths.
func (ps *PathStore) Len() int {
	ps.mu.RLock()
	defer ps.mu.RUnlock()
	return len(ps.chatPaths)
}

// Subscribe returns a channel that receives a signal whenever
// paths change for chatID, along with an unsubscribe function
// that removes the channel.
func (ps *PathStore) Subscribe(chatID uuid.UUID) (<-chan struct{}, func()) {
	ch := make(chan struct{}, 1)

	ps.mu.Lock()
	ps.subscribers[chatID] = append(ps.subscribers[chatID], ch)
	ps.mu.Unlock()

	unsub := func() {
		ps.mu.Lock()
		defer ps.mu.Unlock()
		subs := ps.subscribers[chatID]
		for i, s := range subs {
			if s == ch {
				ps.subscribers[chatID] = append(subs[:i], subs[i+1:]...)
				break
			}
		}
	}

	return ch, unsub
}