cache

type Cache ¶

type Cache struct {
	// contains filtered or unexported fields
}

Cache is a thread-safe TTL + LRU cache.

- If disabled (Config.Enabled=false or Capacity<=0), all operations are no-op and Get returns ErrNotFound. - TTL is optional per entry; 0 means "no expiration" for that entry. - DefaultTTL is applied when Set is called with ttl=0.

This cache is in-memory only (no persistence).

func New(cfg Config, clock Clock) *Cache

func (c *Cache) Delete(key string)

func (c *Cache) Enabled() bool

func (c *Cache) Get(key string) ([]byte, error)

func (c *Cache) Len() int

func (c *Cache) Metrics() Metrics

func (c *Cache) Purge()

func (c *Cache) Set(key string, value []byte, ttl time.Duration)

type Clock ¶

type Clock interface {
	Now() time.Time
}

Clock abstracts time for testability.

NOTE: Use RealClock in production. Tests can provide a fake clock.

type Config ¶

type Config struct {
	Enabled    bool
	Capacity   int           // max number of entries; <=0 means 0 (disabled behavior)
	DefaultTTL time.Duration // 0 means no expiration by default
}

Config defines cache behavior.

type KeyBuilder ¶

type KeyBuilder struct {
	// contains filtered or unexported fields
}

KeyBuilder helps create stable cache keys.

This is intentionally minimal and does not assume any specific caching target. Callers can include provider/model/projectPath/etc. and a content hash.

Example:

kb := cache.NewKeyBuilder("prompt")
key := kb.Add("provider", "openai").Add("model", "gpt-4o").AddHash("system_prompt", prompt).String()

Output format is deterministic.

func NewKeyBuilder(prefix string) *KeyBuilder

func (k *KeyBuilder) Add(name, value string) *KeyBuilder

func (k *KeyBuilder) AddHash(name string, content string) *KeyBuilder

func (k *KeyBuilder) String() string

type Metrics ¶

type Metrics struct {
	Hits   uint64
	Misses uint64
}

Metrics are best-effort counters. All fields are updated under lock.

type RealClock ¶

type RealClock struct{}

RealClock is the production clock.

func (RealClock) Now() time.Time

type RepoMapCacheEntry ¶

type RepoMapCacheEntry struct {
	ProjectPath string `json:"project_path"`
	Fingerprint int64  `json:"fingerprint"` // UnixNano
	RepoMap     string `json:"repo_map"`
}

RepoMapCacheEntry is a persisted repo map cache.

Key is derived from project path (hashed for filename safety). Fingerprint is a best-effort project change detector (max modTime across files).

NOTE: This is intentionally conservative: if fingerprint mismatches, cache is ignored. It is not cryptographically strong; it is intended for speed, not security.