Extract repo from session metadata instead of fetching each session

Avoids N+1 API calls by using session_context.outcomes.git_info.repo
or parsing session_context.sources URL from the sessions list response.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: simonw

src/claude_code_transcripts/__init__.py

@@ -619,30 +619,56 @@ def detect_github_repo(loglines):
     return None
 
 
-def enrich_sessions_with_repos(sessions, token, org_uuid, fetch_fn=None):
-    """Enrich sessions with repo information by fetching each session's details.
+def extract_repo_from_session(session):
+    """Extract GitHub repo from session metadata.
+
+    Looks in session_context.outcomes for git_info.repo,
+    or parses from session_context.sources URL.
+
+    Returns repo as "owner/name" or None.
+    """
+    context = session.get("session_context", {})
+
+    # Try outcomes first (has clean repo format)
+    outcomes = context.get("outcomes", [])
+    for outcome in outcomes:
+        if outcome.get("type") == "git_repository":
+            git_info = outcome.get("git_info", {})
+            repo = git_info.get("repo")
+            if repo:
+                return repo
+
+    # Fall back to sources URL
+    sources = context.get("sources", [])
+    for source in sources:
+        if source.get("type") == "git_repository":
+            url = source.get("url", "")
+            # Parse github.com/owner/repo from URL
+            if "github.com/" in url:
+                # Extract owner/repo from https://github.com/owner/repo
+                match = re.search(r"github\.com/([^/]+/[^/]+?)(?:\.git)?$", url)
+                if match:
+                    return match.group(1)
+
+    return None
+
+
+def enrich_sessions_with_repos(sessions, token=None, org_uuid=None, fetch_fn=None):
+    """Enrich sessions with repo information from session metadata.
 
     Args:
         sessions: List of session dicts from the API
-        token: API access token
-        org_uuid: Organization UUID
-        fetch_fn: Optional function to fetch session data (for testing)
+        token: Unused (kept for backward compatibility)
+        org_uuid: Unused (kept for backward compatibility)
+        fetch_fn: Unused (kept for backward compatibility)
 
     Returns:
         List of session dicts with 'repo' key added
     """
-    if fetch_fn is None:
-        fetch_fn = fetch_session
-
     enriched = []
     for session in sessions:
         session_copy = dict(session)
-        try:
-            session_data = fetch_fn(token, org_uuid, session["id"])
-            loglines = session_data.get("loglines", [])
-            session_copy["repo"] = detect_github_repo(loglines)
-        except Exception:
-            session_copy["repo"] = None
+        session_copy["repo"] = extract_repo_from_session(session)
         enriched.append(session_copy)
     return enriched
 
@@ -1992,9 +2018,8 @@ def web_cmd(
         if not sessions:
             raise click.ClickException("No sessions found.")
 
-        # Enrich sessions with repo information
-        click.echo("Fetching session details to detect repos...")
-        sessions = enrich_sessions_with_repos(sessions, token, org_uuid)
+        # Enrich sessions with repo information (extracted from session metadata)
+        sessions = enrich_sessions_with_repos(sessions)
 
         # Filter by repo if specified
         if repo:

tests/test_all.py

@@ -570,44 +570,76 @@ def test_detect_github_repo_returns_none_when_not_found(self):
         assert repo is None
 
     def test_enrich_sessions_with_repos(self):
-        """Test enriching sessions with repo information."""
+        """Test enriching sessions with repo information from session metadata."""
         from claude_code_transcripts import enrich_sessions_with_repos
 
-        # Mock sessions from the API list
+        # Mock sessions from the API list with session_context
         sessions = [
-            {"id": "sess1", "title": "Session 1", "created_at": "2025-01-01T10:00:00Z"},
-            {"id": "sess2", "title": "Session 2", "created_at": "2025-01-02T10:00:00Z"},
-        ]
-
-        # Mock fetch function that returns session data with loglines
-        def mock_fetch(token, org_uuid, session_id):
-            if session_id == "sess1":
-                return {
-                    "loglines": [
+            {
+                "id": "sess1",
+                "title": "Session 1",
+                "created_at": "2025-01-01T10:00:00Z",
+                "session_context": {
+                    "outcomes": [
                         {
-                            "type": "assistant",
-                            "message": {
-                                "role": "assistant",
-                                "content": [
-                                    {
-                                        "type": "tool_result",
-                                        "content": "https://github.com/simonw/datasette/pull/new/branch",
-                                    }
-                                ],
-                            },
+                            "type": "git_repository",
+                            "git_info": {"repo": "simonw/datasette", "type": "github"},
                         }
                     ]
-                }
-            else:
-                return {"loglines": []}
+                },
+            },
+            {
+                "id": "sess2",
+                "title": "Session 2",
+                "created_at": "2025-01-02T10:00:00Z",
+                "session_context": {},
+            },
+        ]
 
-        enriched = enrich_sessions_with_repos(
-            sessions, "token", "org", fetch_fn=mock_fetch
-        )
+        enriched = enrich_sessions_with_repos(sessions)
 
         assert enriched[0]["repo"] == "simonw/datasette"
         assert enriched[1]["repo"] is None
 
+    def test_extract_repo_from_session_outcomes(self):
+        """Test extracting repo from session_context.outcomes."""
+        from claude_code_transcripts import extract_repo_from_session
+
+        session = {
+            "session_context": {
+                "outcomes": [
+                    {
+                        "type": "git_repository",
+                        "git_info": {"repo": "simonw/llm", "type": "github"},
+                    }
+                ]
+            }
+        }
+        assert extract_repo_from_session(session) == "simonw/llm"
+
+    def test_extract_repo_from_session_sources_url(self):
+        """Test extracting repo from session_context.sources URL."""
+        from claude_code_transcripts import extract_repo_from_session
+
+        session = {
+            "session_context": {
+                "sources": [
+                    {
+                        "type": "git_repository",
+                        "url": "https://github.com/simonw/datasette",
+                    }
+                ]
+            }
+        }
+        assert extract_repo_from_session(session) == "simonw/datasette"
+
+    def test_extract_repo_from_session_no_context(self):
+        """Test extracting repo when no session_context exists."""
+        from claude_code_transcripts import extract_repo_from_session
+
+        session = {"id": "sess1", "title": "No context"}
+        assert extract_repo_from_session(session) is None
+
     def test_filter_sessions_by_repo(self):
         """Test filtering sessions by repo."""
         from claude_code_transcripts import filter_sessions_by_repo