kai_analyzer_rpc/pkg/service/cache.go (2)

72-74: Entries exposes internal map allowing external mutation.

Returning the backing map risks accidental modification outside cache’s lock discipline.

Return a shallow copy:

-func (i *incidentsCache) Entries() map[string][]CacheValue {
-	return i.cache
-}
+func (i *incidentsCache) Entries() map[string][]CacheValue {
+	out := make(map[string][]CacheValue, len(i.cache))
+	for k, v := range i.cache {
+		cpy := make([]CacheValue, len(v))
+		copy(cpy, v)
+		out[k] = cpy
+	}
+	return out
+}

---

64-70: Keys() is unreachable from consumers (not in the interface).

NewIncidentsCache returns IncidentsCache, which lacks Keys(). Either expose it via the interface or remove to avoid dead API.

If unused, remove:

-func (i *incidentsCache) Keys() []string {
-	keys := make([]string, 0, len(i.cache))
-	for k := range i.cache {
-		keys = append(keys, k)
-	}
-	return keys
-}

kai_analyzer_rpc/pkg/service/analyzer.go (3)

266-268: Fix logr key/value usage.

Info requires key/value pairs; passing just a.cache.Len() results in malformed logs.

-		a.Logger.Info("Current cache len", a.cache.Len())
+		a.Logger.Info("Current cache len", "len", a.cache.Len())

---

351-369: Reduce noisy debug logging and avoid logging large incident payloads at info level.

Logging full incidents can be heavy; move to high verbosity or summarize.

-				a.Logger.Info("here update cache incident", "incident", i)
+				a.Logger.V(8).Info("caching incident", "uri", i.URI, "rule", violationName)

---

413-419: Optional: return rulesets in stable order.

Maps iterate in random order; sorting improves determinism across runs.

 	r := []konveyor.RuleSet{}
 	for _, ruleset := range ruleSetMap {
 		r = append(r, ruleset)
 	}
-	a.Logger.V(8).Info("ruleset from cache", "rulesets", r)
+	sort.SliceStable(r, func(i, j int) bool { return r[i].Name < r[j].Name })
+	a.Logger.V(8).Info("ruleset from cache", "rulesets", r)
 	return r

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

kai_analyzer_rpc/pkg/service/cache.go (1)

76-84: Normalize Windows drive letters consistently and fix the misleading comment

The comment says “lowercase” but the code uppercases the volume; also make the normalization deterministic on Windows drives. This directly impacts cache key equality across runs on Windows.

Apply:

@@
-import (
-	"path/filepath"
-	"strings"
-
-	"github.com/go-logr/logr"
-	"github.com/konveyor/analyzer-lsp/output/v1/konveyor"
-)
+import (
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/go-logr/logr"
+	"github.com/konveyor/analyzer-lsp/output/v1/konveyor"
+)
@@
-func normalizePath(path string) string {
-	cleanedPath := filepath.Clean(path)
-	volumeName := filepath.VolumeName(cleanedPath)
-	// make sure all volume names are lowercase
-	if volumeName != "" {
-		cleanedPath = strings.ToUpper(volumeName) + cleanedPath[len(volumeName):]
-	}
-	return filepath.ToSlash(cleanedPath) // prevent forward / backward slashes becoming a problem
+func normalizePath(p string) string {
+	cleaned := filepath.Clean(p)
+	vol := filepath.VolumeName(cleaned)
+	// Normalize Windows drive letters to lowercase for stable keys.
+	if vol != "" && runtime.GOOS == "windows" {
+		cleaned = strings.ToLower(vol) + cleaned[len(vol):]
+	}
+	// Normalize separators to forward slashes.
+	return filepath.ToSlash(cleaned)
 }

Also applies to: 3-9

kai_analyzer_rpc/pkg/service/cache.go (2)

72-74: Avoid leaking internal state from Entries()

Returning the map exposes internal slices to mutation by callers. Return a defensive copy.

 func (i *incidentsCache) Entries() map[string][]CacheValue {
-	return i.cache
+	out := make(map[string][]CacheValue, len(i.cache))
+	for k, v := range i.cache {
+		cp := make([]CacheValue, len(v))
+		copy(cp, v)
+		out[k] = cp
+	}
+	return out
 }

---

11-17: Align Keys() with the interface (or make it private)

Constructor returns IncidentsCache; Keys() isn’t on the interface, so consumers can’t use it without type assertions.

Option A (expose via interface):

 type IncidentsCache interface {
 	Get(path string) ([]CacheValue, bool)
 	Add(path string, value CacheValue)
 	Delete(path string)
 	Len() int
 	Entries() map[string][]CacheValue
+	Keys() []string
 }

Option B (make it private if internal-only):

-func (i *incidentsCache) Keys() []string {
+func (i *incidentsCache) keys() []string {

Also applies to: 64-70

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

kai_analyzer_rpc/pkg/service/cache.go (2)

83-94: Good: Entries() deep-clones to avoid sharing internal state.

This addresses prior feedback about synchronization and exposure. Nice.

---

35-39: Concurrency approach looks good; mutex guards the map.

Addresses earlier concern about concurrent access to the cache.

kai_analyzer_rpc/pkg/service/cache.go (2)

27-33: Nit: zero-value RWMutex is ready; explicit init is unnecessary.

Small cleanup; no behavior change.

 func NewIncidentsCache(logger logr.Logger) IncidentsCache {
   return &incidentsCache{
     cache:  map[string][]CacheValue{},
     logger: logger,
-    mutex:  sync.RWMutex{},
   }
 }

---

73-81: Optional: sort Keys() for deterministic iteration/logs.

Useful for stable tests and diagnostics.

+// add: import "sort"
 func (i *incidentsCache) Keys() []string {
   i.mutex.RLock()
   defer i.mutex.RUnlock()
   keys := make([]string, 0, len(i.cache))
   for k := range i.cache {
     keys = append(keys, k)
   }
-  return keys
+  sort.Strings(keys)
+  return keys
 }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: pranavgaikwad
PR: konveyor/kai#864
File: kai_analyzer_rpc/pkg/service/analyzer.go:374-379
Timestamp: 2025-09-10T22:52:55.595Z
Learning: In kai_analyzer_rpc/pkg/service/analyzer.go, the analyzer only receives file paths from within the workspace, so path normalization before cache operations is not needed as paths are already consistently formatted.

Learnt from: pranavgaikwad
PR: konveyor/kai#864
File: kai_analyzer_rpc/pkg/service/analyzer.go:374-379
Timestamp: 2025-09-10T22:52:55.595Z
Learning: In kai_analyzer_rpc/pkg/service/analyzer.go, the analyzer only receives file paths from within the workspace, so path normalization before cache operations is not needed as paths are already consistently formatted.

kai_analyzer_rpc/pkg/service/analyzer.go (1)

367-371: No analyzer-side path normalization needed here.

Sticking to raw p is consistent with earlier discussion that analyzer only receives workspace paths; the cache layer now normalizes. This resolves the prior suggestion about normalizing in invalidateCachePerFile.

kai_analyzer_rpc/pkg/service/analyzer.go (5)

264-265: Fix structured logging key/value usage.

logr expects even key/value pairs with string keys. This call passes only a value.

Apply:

- a.Logger.Info("Current cache len", a.cache.Len())
+ a.Logger.Info("Current cache len", "len", a.cache.Len())

---

299-300: Reduce noisy high-volume logging.

Dumping full rulesets at V(8) can be very large; logging the count is usually enough.

Apply:

- a.Logger.V(8).Info("got rulesets", "rulesets", rulesets)
+ a.Logger.V(8).Info("got rulesets", "count", len(rulesets))

---

333-338: Minor: simplify nil-check.

updateCache is only called when len(args.IncludedPaths) > 0; the includedPaths != nil guard is redundant.

Apply:

- if includedPaths != nil {
-   a.invalidateCachePerFile(includedPaths)
- }
+ a.invalidateCachePerFile(includedPaths)

---

374-409: Return deterministic, stable ordering from cache results.

Entries() already returns a cloned snapshot (kai_analyzer_rpc/pkg/service/cache.go: Entries), so apply the sort/alloc/log change only.

- r := []konveyor.RuleSet{}
+ r := make([]konveyor.RuleSet, 0, len(ruleSetMap))
 for _, ruleset := range ruleSetMap {
   r = append(r, ruleset)
 }
- a.Logger.V(8).Info("ruleset from cache", "rulesets", r)
+ sort.SliceStable(r, func(i, j int) bool { return r[i].Name < r[j].Name })
+ a.Logger.V(8).Info("ruleset from cache", "count", len(r))
 return r

---

344-362: Demote noisy log and confirm cache-key semantics.

File: kai_analyzer_rpc/pkg/service/analyzer.go (lines 344–362)

• Replace the noisy info log with a verbose path-only log:

- a.Logger.Info("here update cache incident", "incident", i)
+ a.Logger.V(8).Info("updating cache incident", "path", i.URI.Filename())

• Verified: kai_analyzer_rpc/pkg/service/cache.go::normalizePath calls filepath.Clean, uppercases VolumeName (Windows) and filepath.ToSlash; Add/Get/Delete normalize keys internally — using i.URI.Filename() as the cache key is acceptable.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: pranavgaikwad
PR: konveyor/kai#864
File: kai_analyzer_rpc/pkg/service/analyzer.go:374-379
Timestamp: 2025-09-10T22:52:55.595Z
Learning: In kai_analyzer_rpc/pkg/service/analyzer.go, the analyzer only receives file paths from within the workspace, so path normalization before cache operations is not needed as paths are already consistently formatted.

Learnt from: pranavgaikwad
PR: konveyor/kai#864
File: kai_analyzer_rpc/pkg/service/analyzer.go:374-379
Timestamp: 2025-09-10T22:52:55.595Z
Learning: In kai_analyzer_rpc/pkg/service/analyzer.go, the analyzer only receives file paths from within the workspace, so path normalization before cache operations is not needed as paths are already consistently formatted.