perf(ranking): memoize prompt-independent _analyze_corpus (skips O(N^2) import-graph rebuild)

_analyze_corpus is prompt-independent but re-ran on every query, and its import-graph
build is O(N^2) (per file, _resolve_import linear-scans all files per import). On a
long-lived ranker (the MCP server) this dominated end-to-end latency on large trees
(~84s warm on ~1100 files). Memoize the result keyed by each file's path + content
hash, so repeated queries on an unchanged tree reuse it (byte-identical stats) and an
edit invalidates it. Measured: _analyze_corpus warm 0.93s -> 0.0001s. (Cold/first build
still pays the O(N^2); the algorithmic fix is a separate change.)

Author: jddunn

tenets/core/ranking/ranker.py

@@ -698,6 +698,14 @@ def _analyze_corpus(
         Returns:
             Dictionary of corpus statistics
         """
+        # Memoize this prompt-independent analysis. A long-lived ranker (the MCP
+        # server) re-runs _analyze_corpus on every query, and its import-graph build
+        # is O(N^2); reuse the result whenever the file set + contents are unchanged.
+        _sig = self._corpus_sig(files)
+        _memo = getattr(self, "_corpus_memo", None)
+        if _memo is not None and _memo[0] == _sig:
+            return _memo[1]
+
         self.logger.debug(f"Analyzing corpus of {len(files)} files")
 
         stats = {
@@ -808,8 +816,26 @@ def _analyze_corpus(
             f"{stats['total_imports']} imports"
         )
 
+        self._corpus_memo = (_sig, stats)
         return stats
 
+    def _corpus_sig(self, files: List[FileAnalysis]) -> str:
+        """Signature of the (prompt-independent) corpus, for memoizing _analyze_corpus.
+
+        Keyed on each file's path + content hash (already computed by the analyzer),
+        so an edited file invalidates the memo. Falls back to size when hash is absent.
+        """
+        import hashlib
+
+        h = hashlib.md5()
+        for f in sorted(files, key=lambda x: getattr(x, "path", "") or ""):
+            h.update((getattr(f, "path", "") or "").encode("utf-8", "replace"))
+            token = getattr(f, "hash", None)
+            if not token:
+                token = getattr(f, "size", None)
+            h.update(str(token).encode("utf-8", "replace"))
+        return h.hexdigest()
+
     def _get_corpus_index(self):
         """Lazily construct the persistent corpus index (None if disabled).
 

tests/core/ranker/test_corpus_memo.py

@@ -0,0 +1,42 @@
+"""_analyze_corpus is prompt-independent and O(N^2) (import graph) — memoize it so a
+long-lived ranker (the MCP server) doesn't recompute it on every query."""
+from unittest.mock import MagicMock, patch
+
+from tenets.config import TenetsConfig
+from tenets.core.ranking.ranker import RelevanceRanker
+from tenets.models.analysis import FileAnalysis
+
+
+def _fa(path, content, h):
+    return FileAnalysis(
+        path=path, content=content, language="python", size=len(content), imports=[], hash=h
+    )
+
+
+def _ranker():
+    cfg = TenetsConfig()
+    cfg.cache.index_enabled = False  # isolate the memo from the disk corpus index
+    return RelevanceRanker(cfg)
+
+
+def test_analyze_corpus_is_memoized_for_unchanged_files():
+    r = _ranker()
+    files = [_fa("a.py", "import os\nclass FileHandler: pass", "h1"),
+             _fa("b.py", "def write_file(): pass", "h2")]
+    pc = MagicMock()
+    with patch.object(r, "_build_dependency_tree", wraps=r._build_dependency_tree) as spy:
+        s1 = r._analyze_corpus(files, pc)
+        s2 = r._analyze_corpus(files, pc)
+    assert s2 is s1  # memoized: same stats object returned
+    assert spy.call_count == 1  # heavy (O(N^2)) work ran exactly once
+
+
+def test_memo_invalidates_when_a_file_changes():
+    r = _ranker()
+    files = [_fa("a.py", "alpha", "h1"), _fa("b.py", "bravo", "h2")]
+    pc = MagicMock()
+    with patch.object(r, "_build_dependency_tree", wraps=r._build_dependency_tree) as spy:
+        r._analyze_corpus(files, pc)
+        changed = [_fa("a.py", "alpha changed", "h1-NEW"), files[1]]
+        r._analyze_corpus(changed, pc)
+    assert spy.call_count == 2  # content hash changed -> recompute, no stale memo