feat: add caching infrastructure for Drive metadata (#83)

* ci: add test workflows, manual publish, and snap support

- Add test-chocolatey.yml: validates Chocolatey packaging on PRs
- Add test-winget.yml: validates Winget manifest schema on PRs
- Add chocolatey-publish.yml: manual workflow to publish to Chocolatey
- Add winget-publish.yml: manual workflow to publish to Winget
- Add snap/snapcraft.yaml: Snap package definition
- Add snap job to release.yml (disabled, awaiting personal-files approval)
- Migrate Homebrew to goreleaser homebrew_casks (cleaner, includes xattr)
- Remove manual update-homebrew job from release.yml

* feat: add caching infrastructure for Drive metadata

Add a caching layer to support fast repeated lookups for Drive API metadata
(shared drive lists, etc). This is Phase 1 of shared drive support.

New files:
- internal/cache/cache.go: TTL-based cache implementation with GetDrives,
  SetDrives, Clear, and GetStatus methods
- internal/cache/cache_test.go: Comprehensive tests for cache package
- internal/cmd/config/cache.go: Cache management commands (show, clear, ttl)

Modified files:
- internal/config/config.go: Add Config struct, LoadConfig, SaveConfig,
  GetCacheTTL functions for persisting user settings
- internal/cmd/config/config.go: Register cache subcommand
- internal/cmd/initcmd/init.go: Add cache TTL prompt during setup
- README.md: Document cache configuration and commands

Features:
- Configurable cache TTL (default 24 hours) set during `gro init`
- `gro config cache show` - display cache status
- `gro config cache clear` - clear all cached data
- `gro config cache ttl <hours>` - update cache TTL
- Cache stored in ~/.config/google-readonly/cache/
- Automatic expiration based on TTL

Author: rianjs

README.md

@@ -167,6 +167,15 @@ gro config test
 # Clear stored OAuth token
 gro config clear
 
+# View cache status
+gro config cache show
+
+# Clear cached data
+gro config cache clear
+
+# Set cache TTL (in hours)
+gro config cache ttl 12
+
 # Show version
 gro --version
 ```
@@ -268,6 +277,33 @@ Remove stored OAuth token (forces re-authentication).
 Usage: gro config clear
 ```
 
+### gro config cache show
+
+Display cache status including location, TTL, and cached data status.
+
+```
+Usage: gro config cache show [flags]
+
+Flags:
+  -j, --json       Output as JSON
+```
+
+### gro config cache clear
+
+Remove all cached data. Cache will be repopulated on next use.
+
+```
+Usage: gro config cache clear
+```
+
+### gro config cache ttl
+
+Set the cache time-to-live in hours.
+
+```
+Usage: gro config cache ttl <hours>
+```
+
 ### gro mail search
 
 Search for Gmail messages using Gmail's search syntax.
@@ -685,6 +721,25 @@ Configuration files are stored in `~/.config/google-readonly/`:
 |------|-------------|
 | `credentials.json` | OAuth client credentials (from Google Cloud Console) |
 | `token.json` | OAuth access/refresh token (fallback if keychain unavailable) |
+| `config.json` | User settings (cache TTL, etc.) |
+| `cache/` | Cached API metadata for faster repeated lookups |
+
+### Cache Settings
+
+gro caches Drive metadata (like shared drive lists) to speed up repeated commands. The cache TTL is configured during `gro init` (default: 24 hours).
+
+```bash
+# View cache status
+gro config cache show
+
+# Clear cache
+gro config cache clear
+
+# Change cache TTL
+gro config cache ttl 12    # Set to 12 hours
+```
+
+The cache is automatically repopulated when stale or after being cleared.
 
 ## Security
 

internal/cache/cache.go

@@ -0,0 +1,159 @@
+// Package cache provides TTL-based caching for API metadata.
+package cache
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/open-cli-collective/google-readonly/internal/config"
+)
+
+const (
+	// DefaultTTLHours is the default cache TTL if not configured
+	DefaultTTLHours = 24
+	// CacheDir is the subdirectory within config for cache files
+	CacheDir = "cache"
+	// DrivesFile is the cache file for shared drives
+	DrivesFile = "drives.json"
+)
+
+// CachedDrive represents a cached shared drive entry
+type CachedDrive struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+}
+
+// DriveCache represents the cached shared drives data
+type DriveCache struct {
+	CachedAt time.Time      `json:"cached_at"`
+	TTLHours int            `json:"ttl_hours"`
+	Drives   []*CachedDrive `json:"drives"`
+}
+
+// Cache provides TTL-based caching for API metadata
+type Cache struct {
+	dir      string
+	ttlHours int
+}
+
+// New creates a new Cache instance
+func New(ttlHours int) (*Cache, error) {
+	configDir, err := config.GetConfigDir()
+	if err != nil {
+		return nil, err
+	}
+
+	cacheDir := filepath.Join(configDir, CacheDir)
+	if err := os.MkdirAll(cacheDir, config.DirPerm); err != nil {
+		return nil, err
+	}
+
+	if ttlHours <= 0 {
+		ttlHours = DefaultTTLHours
+	}
+
+	return &Cache{
+		dir:      cacheDir,
+		ttlHours: ttlHours,
+	}, nil
+}
+
+// GetDrives returns cached shared drives, or nil if cache is stale or missing
+func (c *Cache) GetDrives() ([]*CachedDrive, error) {
+	path := filepath.Join(c.dir, DrivesFile)
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil // Cache miss, not an error
+		}
+		return nil, err
+	}
+
+	var cache DriveCache
+	if err := json.Unmarshal(data, &cache); err != nil {
+		// Corrupted cache, treat as miss
+		return nil, nil
+	}
+
+	// Check if cache is stale
+	ttl := time.Duration(cache.TTLHours) * time.Hour
+	if time.Since(cache.CachedAt) > ttl {
+		return nil, nil // Cache expired
+	}
+
+	return cache.Drives, nil
+}
+
+// SetDrives updates the cached shared drives
+func (c *Cache) SetDrives(drives []*CachedDrive) error {
+	cache := DriveCache{
+		CachedAt: time.Now(),
+		TTLHours: c.ttlHours,
+		Drives:   drives,
+	}
+
+	data, err := json.MarshalIndent(cache, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	path := filepath.Join(c.dir, DrivesFile)
+	return os.WriteFile(path, data, config.TokenPerm)
+}
+
+// Clear removes all cached data
+func (c *Cache) Clear() error {
+	return os.RemoveAll(c.dir)
+}
+
+// Status returns information about the cache state
+type Status struct {
+	Dir         string    `json:"dir"`
+	TTLHours    int       `json:"ttl_hours"`
+	DrivesCache *FileInfo `json:"drives_cache,omitempty"`
+}
+
+// FileInfo contains information about a cache file
+type FileInfo struct {
+	Path      string    `json:"path"`
+	CachedAt  time.Time `json:"cached_at"`
+	ExpiresAt time.Time `json:"expires_at"`
+	IsStale   bool      `json:"is_stale"`
+	Count     int       `json:"count"`
+}
+
+// GetStatus returns the current cache status
+func (c *Cache) GetStatus() (*Status, error) {
+	status := &Status{
+		Dir:      c.dir,
+		TTLHours: c.ttlHours,
+	}
+
+	// Check drives cache
+	drivesPath := filepath.Join(c.dir, DrivesFile)
+	data, err := os.ReadFile(drivesPath)
+	if err == nil {
+		var cache DriveCache
+		if json.Unmarshal(data, &cache) == nil {
+			ttl := time.Duration(cache.TTLHours) * time.Hour
+			expiresAt := cache.CachedAt.Add(ttl)
+			status.DrivesCache = &FileInfo{
+				Path:      drivesPath,
+				CachedAt:  cache.CachedAt,
+				ExpiresAt: expiresAt,
+				IsStale:   time.Now().After(expiresAt),
+				Count:     len(cache.Drives),
+			}
+		}
+	}
+
+	return status, nil
+}
+
+// GetDir returns the cache directory path
+func (c *Cache) GetDir() string {
+	return c.dir
+}