feat: add search, filter, and caching features (v0.2.0)

New features:
- / : Fuzzy search repos by name, path, or branch (live search-as-you-type)
- f : Toggle filter between All/Dirty Only/Clean Only
- c : Clear all search and filter settings
- JSON caching in ~/.cache/git-scope/repos.json (5 min TTL)
- Search bar UI with active query display
- Filter badge in stats bar
- Updated help text for all modes

Author: Bharath-code

cmd/git-scope/main.go

@@ -14,7 +14,7 @@ import (
 	"github.com/Bharath-code/git-scope/internal/tui"
 )
 
-const version = "0.1.3"
+const version = "0.2.0"
 
 func usage() {
 	fmt.Fprintf(os.Stderr, `git-scope v%s — A fast TUI to see the status of all git repositories

go.mod

@@ -10,6 +10,7 @@ require (
 )
 
 require (
+	github.com/atotto/clipboard v0.1.4 // indirect
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
 	github.com/charmbracelet/x/ansi v0.1.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect

go.sum

@@ -1,3 +1,5 @@
+github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
+github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
 github.com/charmbracelet/bubbles v0.18.0 h1:PYv1A036luoBGroX6VWjQIE9Syf2Wby2oOl/39KLfy0=

internal/cache/cache.go

@@ -1,12 +1,118 @@
 package cache
 
-import "github.com/Bharath-code/git-scope/internal/model"
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"time"
 
-// Store defines the interface for caching repo data
+	"github.com/Bharath-code/git-scope/internal/model"
+)
+
+// CacheData represents the cached scan results
+type CacheData struct {
+	Repos     []model.Repo `json:"repos"`
+	Timestamp time.Time    `json:"timestamp"`
+	Roots     []string     `json:"roots"`
+}
+
+// Store interface for caching repo data
 type Store interface {
-	Load() ([]model.Repo, error)
-	Save([]model.Repo) error
+	Load() (*CacheData, error)
+	Save(repos []model.Repo, roots []string) error
+	IsValid(maxAge time.Duration) bool
+}
+
+// FileStore implements Store using a JSON file
+type FileStore struct {
+	path string
+	data *CacheData
+}
+
+// NewFileStore creates a new file-based cache store
+func NewFileStore() *FileStore {
+	return &FileStore{
+		path: getCachePath(),
+	}
+}
+
+// getCachePath returns the path to the cache file
+func getCachePath() string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return ""
+	}
+	return filepath.Join(home, ".cache", "git-scope", "repos.json")
+}
+
+// Load reads cached data from disk
+func (s *FileStore) Load() (*CacheData, error) {
+	data, err := os.ReadFile(s.path)
+	if err != nil {
+		return nil, err
+	}
+
+	var cache CacheData
+	if err := json.Unmarshal(data, &cache); err != nil {
+		return nil, err
+	}
+
+	s.data = &cache
+	return &cache, nil
 }
 
-// TODO: Implement JSON or SQLite-backed store for faster startup
-// This is a stub for the MVP - caching will be added in a future version
+// Save writes repos to cache file
+func (s *FileStore) Save(repos []model.Repo, roots []string) error {
+	cache := CacheData{
+		Repos:     repos,
+		Timestamp: time.Now(),
+		Roots:     roots,
+	}
+
+	// Ensure cache directory exists
+	dir := filepath.Dir(s.path)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return err
+	}
+
+	data, err := json.MarshalIndent(cache, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(s.path, data, 0644)
+}
+
+// IsValid checks if cache is still valid based on max age
+func (s *FileStore) IsValid(maxAge time.Duration) bool {
+	if s.data == nil {
+		return false
+	}
+	return time.Since(s.data.Timestamp) < maxAge
+}
+
+// IsSameRoots checks if cached roots match current roots
+func (s *FileStore) IsSameRoots(roots []string) bool {
+	if s.data == nil || len(s.data.Roots) != len(roots) {
+		return false
+	}
+	for i, r := range roots {
+		if s.data.Roots[i] != r {
+			return false
+		}
+	}
+	return true
+}
+
+// GetTimestamp returns the cache timestamp
+func (s *FileStore) GetTimestamp() time.Time {
+	if s.data == nil {
+		return time.Time{}
+	}
+	return s.data.Timestamp
+}
+
+// Clear removes the cache file
+func (s *FileStore) Clear() error {
+	return os.Remove(s.path)
+}

internal/tui/app.go

@@ -1,12 +1,18 @@
 package tui
 
 import (
+	"time"
+
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/Bharath-code/git-scope/internal/cache"
 	"github.com/Bharath-code/git-scope/internal/config"
 	"github.com/Bharath-code/git-scope/internal/model"
 	"github.com/Bharath-code/git-scope/internal/scan"
 )
 
+// Cache max age - use cached data if less than 5 minutes old
+const cacheMaxAge = 5 * time.Minute
+
 // Run starts the Bubbletea TUI application
 func Run(cfg *config.Config) error {
 	m := NewModel(cfg)
@@ -18,17 +24,38 @@ func Run(cfg *config.Config) error {
 // scanReposCmd is a command that scans for repositories
 func scanReposCmd(cfg *config.Config) tea.Cmd {
 	return func() tea.Msg {
+		// Try to load from cache first
+		cacheStore := cache.NewFileStore()
+		cached, err := cacheStore.Load()
+		
+		if err == nil && cacheStore.IsValid(cacheMaxAge) && cacheStore.IsSameRoots(cfg.Roots) {
+			// Use cached data but trigger background refresh
+			return scanCompleteMsg{
+				repos:    cached.Repos,
+				fromCache: true,
+			}
+		}
+		
+		// Scan fresh
 		repos, err := scan.ScanRoots(cfg.Roots, cfg.Ignore)
 		if err != nil {
 			return scanErrorMsg{err: err}
 		}
-		return scanCompleteMsg{repos: repos}
+		
+		// Save to cache
+		_ = cacheStore.Save(repos, cfg.Roots)
+		
+		return scanCompleteMsg{
+			repos:    repos,
+			fromCache: false,
+		}
 	}
 }
 
 // scanCompleteMsg is sent when scanning is complete
 type scanCompleteMsg struct {
-	repos []model.Repo
+	repos     []model.Repo
+	fromCache bool
 }
 
 // scanErrorMsg is sent when scanning fails

internal/tui/model.go

@@ -3,8 +3,10 @@ package tui
 import (
 	"fmt"
 	"sort"
+	"strings"
 
 	"github.com/charmbracelet/bubbles/table"
+	"github.com/charmbracelet/bubbles/textinput"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
 	"github.com/Bharath-code/git-scope/internal/config"
@@ -18,6 +20,7 @@ const (
 	StateLoading State = iota
 	StateReady
 	StateError
+	StateSearching
 )
 
 // SortMode represents different sorting options
@@ -30,24 +33,37 @@ const (
 	SortByLastCommit
 )
 
+// FilterMode represents different filter options
+type FilterMode int
+
+const (
+	FilterAll FilterMode = iota
+	FilterDirty
+	FilterClean
+)
+
 // Model is the Bubbletea model for the TUI
 type Model struct {
-	cfg        *config.Config
-	table      table.Model
-	repos      []model.Repo
-	sortedRepos []model.Repo  // Sorted copy for display
-	state      State
-	err        error
-	statusMsg  string
-	width      int
-	height     int
-	sortMode   SortMode
+	cfg         *config.Config
+	table       table.Model
+	textInput   textinput.Model
+	repos       []model.Repo
+	filteredRepos []model.Repo  // After filter applied
+	sortedRepos []model.Repo   // After sort applied
+	state       State
+	err         error
+	statusMsg   string
+	width       int
+	height      int
+	sortMode    SortMode
+	filterMode  FilterMode
+	searchQuery string
 }
 
 // NewModel creates a new TUI model
 func NewModel(cfg *config.Config) Model {
 	columns := []table.Column{
-		{Title: "Status", Width: 6},
+		{Title: "Status", Width: 8},
 		{Title: "Repository", Width: 18},
 		{Title: "Branch", Width: 14},
 		{Title: "Staged", Width: 6},
@@ -85,11 +101,19 @@ func NewModel(cfg *config.Config) Model {
 
 	t.SetStyles(s)
 
+	// Create text input for search
+	ti := textinput.New()
+	ti.Placeholder = "Search repos..."
+	ti.CharLimit = 50
+	ti.Width = 30
+
 	return Model{
-		cfg:      cfg,
-		table:    t,
-		state:    StateLoading,
-		sortMode: SortByDirty,
+		cfg:        cfg,
+		table:      t,
+		textInput:  ti,
+		state:      StateLoading,
+		sortMode:   SortByDirty,
+		filterMode: FilterAll,
 	}
 }
 
@@ -111,10 +135,45 @@ func (m Model) GetSelectedRepo() *model.Repo {
 	return nil
 }
 
-// sortRepos sorts repos based on current sort mode
+// applyFilter filters repos based on current filter mode and search query
+func (m *Model) applyFilter() {
+	m.filteredRepos = make([]model.Repo, 0, len(m.repos))
+	
+	for _, r := range m.repos {
+		// Apply filter mode
+		switch m.filterMode {
+		case FilterDirty:
+			if !r.Status.IsDirty {
+				continue
+			}
+		case FilterClean:
+			if r.Status.IsDirty {
+				continue
+			}
+		}
+		
+		// Apply search query
+		if m.searchQuery != "" {
+			query := strings.ToLower(m.searchQuery)
+			name := strings.ToLower(r.Name)
+			path := strings.ToLower(r.Path)
+			branch := strings.ToLower(r.Status.Branch)
+			
+			if !strings.Contains(name, query) && 
+			   !strings.Contains(path, query) &&
+			   !strings.Contains(branch, query) {
+				continue
+			}
+		}
+		
+		m.filteredRepos = append(m.filteredRepos, r)
+	}
+}
+
+// sortRepos sorts the filtered repos based on current sort mode
 func (m *Model) sortRepos() {
-	m.sortedRepos = make([]model.Repo, len(m.repos))
-	copy(m.sortedRepos, m.repos)
+	m.sortedRepos = make([]model.Repo, len(m.filteredRepos))
+	copy(m.sortedRepos, m.filteredRepos)
 
 	switch m.sortMode {
 	case SortByDirty:
@@ -139,8 +198,9 @@ func (m *Model) sortRepos() {
 	}
 }
 
-// updateTable refreshes the table with current sorted repos
+// updateTable refreshes the table with current filtered and sorted repos
 func (m *Model) updateTable() {
+	m.applyFilter()
 	m.sortRepos()
 	m.table.SetRows(reposToRows(m.sortedRepos))
 }
@@ -160,6 +220,19 @@ func (m Model) GetSortModeName() string {
 	return "Unknown"
 }
 
+// GetFilterModeName returns the display name of current filter mode
+func (m Model) GetFilterModeName() string {
+	switch m.filterMode {
+	case FilterAll:
+		return "All"
+	case FilterDirty:
+		return "Dirty Only"
+	case FilterClean:
+		return "Clean Only"
+	}
+	return "All"
+}
+
 // reposToRows converts repos to table rows with status indicators
 func reposToRows(repos []model.Repo) []table.Row {
 	rows := make([]table.Row, 0, len(repos))