gitradar 0.1.5__py3-none-any.whl

gitradar/prompts/gap_analysis_system.j2

@@ -0,0 +1,36 @@
+You are an expert in Market & Gap Analysis for software developer tools.
+You will be given a new developer project idea and a list of existing candidate open-source repositories found on GitHub.
+Your task is to analyze these repositories semantically and generate an executive market report.
+Provide ALL report text contents (summaries, strengths, gaps, differentiators, recommendations, architecture) strictly in {{ language | default('English') }}.
+Return ONLY a valid JSON object matching the requested schema below.
+
+Required JSON Schema:
+{
+  "idea_summary": "Concise summary of the project idea",
+  "market_saturation": "Low | Moderate | High",
+  "saturation_score": 45,
+  "market_summary": "Overview of the current market state...",
+  "top_competitors": [
+    {
+      "repo_name": "owner/repo",
+      "key_strengths": ["Strength 1", "Strength 2"],
+      "weaknesses_or_gaps": ["Weakness or Gap 1", "Gap 2"]
+    }
+  ],
+  "unmet_needs": ["Unmet need or gap in existing repos 1", "Gap 2"],
+  "differentiators": ["Feature to differentiate project 1", "Feature 2"],
+  "actionable_recommendations": ["Recommendation 1", "Recommendation 2"],
+  "opportunity_score": 85,
+  "implementation_guide": {
+    "recommended_tech_stack": ["Python / Rust", "Typer", "LiteLLM", "Qdrant"],
+    "architecture_overview": "Comprehensive explanation of how this software should be built, structured, and architected step-by-step...",
+    "open_source_building_blocks": [
+      {
+        "name": "Open-Source Tool Name",
+        "category": "CLI Framework | Vector DB | LLM SDK | Parser | UI | Async Engine",
+        "description_and_usage": "Detailed guidance on how and why to leverage this specific open-source library in building the project.",
+        "repo_url": "https://github.com/owner/repo"
+      }
+    ]
+  }
+}

gitradar/prompts/gap_analysis_user.j2

@@ -0,0 +1,21 @@
+Developer Project Idea:
+{{ idea }}
+
+Existing Candidate Repositories Found on GitHub ({{ repositories|length }} items):
+{% if repositories %}
+{% for r in repositories %}
+{{ loop.index }}. Repo: {{ r.full_name }}
+   Stars: {{ r.stars }} | Forks: {{ r.forks }} | Language: {{ r.language }}
+   Description: {{ r.description }}
+   Topics: {{ r.topics|join(', ') }}
+{% if r.readme_snippet %}
+   README Snippet: {{ r.readme_snippet[:300] }}...
+{% endif %}
+
+{% endfor %}
+{% else %}
+No directly relevant repositories found.
+{% endif %}
+
+CRITICAL LANGUAGE INSTRUCTION:
+Generate ALL report text content (idea_summary, market_summary, key_strengths, weaknesses_or_gaps, unmet_needs, differentiators, actionable_recommendations, architecture_overview, and open_source_building_blocks descriptions) strictly in {{ language | default('English') }}.

gitradar/prompts/query_expansion_system.j2

@@ -0,0 +1,19 @@
+You are a Senior GitHub and Software Architect.
+The user will provide a software project idea.
+Your task is to derive targeted, highly specific search keywords, exact key phrases, GitHub topics, and target languages to query the GitHub REST API efficiently.
+
+Guidelines for `search_keywords`:
+- Include multi-word specific key phrases (e.g., "terminal code review", "git diff analyzer", "k8s log explainer") to target niche projects rather than overly generic single words.
+- Focus on the core functionality, domain, and problem solved by the project idea.
+- Provide 3 to 6 distinct keywords/phrases.
+
+Provide search_explanation text in {{ language | default('English') }}. Note that search keywords and GitHub topics must remain in English for GitHub API query accuracy.
+Return ONLY a valid JSON object matching the requested schema below.
+
+Required JSON Schema:
+{
+  "search_keywords": ["specific phrase 1", "targeted keyword 2", "domain keyword 3"],
+  "github_topics": ["topic1", "topic2"],
+  "target_languages": ["Python", "Rust"],
+  "search_explanation": "Brief explanation of the search strategy"
+}

gitradar/prompts/query_expansion_user.j2

@@ -0,0 +1 @@
+Project Idea: {{ idea }}

gitradar/prompts/relevance_evaluation_system.j2

@@ -0,0 +1,22 @@
+You are an expert Software Product Manager and Competitive Intelligence Analyst.
+Given a developer project idea concept and a list of candidate GitHub repositories found via search, your task is to evaluate the relevance of each repository against the core concept of the project idea.
+
+For each repository in the list, evaluate:
+1. `relevance_score`: Integer from 0 to 100 representing how closely the repository matches or competes with the core purpose of the project idea.
+   - 80-100: Direct match or primary competitor offering similar core functionality.
+   - 50-79: Indirect match or partial overlap (solves part of the problem or related tooling).
+   - 0-49: Low relevance, generic infrastructure, or tangentially related project matching only surface keywords.
+2. `is_direct_competitor`: Boolean (true if relevance_score >= 60, false otherwise).
+3. `relevance_reason`: Brief 1-sentence explanation of why it matches or differs from the user's idea in {{ language | default('English') }}.
+
+Return ONLY a valid JSON object matching the schema below:
+{
+  "evaluations": [
+    {
+      "full_name": "owner/repo",
+      "relevance_score": 85,
+      "is_direct_competitor": true,
+      "relevance_reason": "Brief explanation of fit"
+    }
+  ]
+}

gitradar/prompts/relevance_evaluation_user.j2

@@ -0,0 +1,14 @@
+Developer Project Idea: {{ idea }}
+
+Candidate Repositories to Evaluate:
+{% for repo in repos %}
+- Repository: {{ repo.full_name }}
+  Description: {{ repo.description }}
+  Topics: {{ repo.topics | join(', ') if repo.topics else 'None' }}
+  Language: {{ repo.language }}
+  Stars: {{ repo.stars }}
+  {% if repo.readme_snippet %}
+  README Snippet: {{ repo.readme_snippet[:300] }}
+  {% endif %}
+
+{% endfor %}

gitradar/services/github.py

@@ -0,0 +1,179 @@
+import asyncio
+from typing import List, Optional, Dict, Any
+import httpx
+from gitradar.config import settings
+from gitradar.models import RepositoryInfo
+
+GITHUB_API_BASE = "https://api.github.com"
+
+
+class GitHubService:
+    """Asynchronous client for interacting with the GitHub REST API."""
+
+    def __init__(self, token: Optional[str] = None):
+        self.token = token or settings.github_token
+        self.headers = {
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "GitRadar-CLI/0.1.0",
+        }
+        if self.token:
+            self.headers["Authorization"] = f"Bearer {self.token}"
+
+    async def search_repositories(
+        self,
+        query: str,
+        limit: int = 10,
+        sort: str = "stars",
+        order: str = "desc"
+    ) -> List[RepositoryInfo]:
+        """Search GitHub repositories based on query string."""
+        url = f"{GITHUB_API_BASE}/search/repositories"
+        params = {
+            "q": query,
+            "sort": sort,
+            "order": order,
+            "per_page": min(limit, 100),
+        }
+
+        async with httpx.AsyncClient(timeout=15.0) as client:
+            response = await client.get(url, headers=self.headers, params=params)
+            
+            if response.status_code == 403:
+                raise RuntimeError(
+                    "GitHub API Rate Limit Exceeded. "
+                    "Please configure a GITHUB_TOKEN (`gitradar config --github-token YOUR_TOKEN`)."
+                )
+            elif response.status_code != 200:
+                raise RuntimeError(f"GitHub API Error ({response.status_code}): {response.text}")
+
+            data = response.json()
+            items = data.get("items", [])
+
+            results: List[RepositoryInfo] = []
+            for item in items[:limit]:
+                repo = RepositoryInfo(
+                    full_name=item.get("full_name", ""),
+                    name=item.get("name", ""),
+                    owner=item.get("owner", {}).get("login", ""),
+                    html_url=item.get("html_url", ""),
+                    description=item.get("description") or "No description provided",
+                    stars=item.get("stargazers_count", 0),
+                    forks=item.get("forks_count", 0),
+                    language=item.get("language") or "Unspecified",
+                    topics=item.get("topics", []),
+                    updated_at=item.get("updated_at", "")[:10] if item.get("updated_at") else "",
+                    open_issues=item.get("open_issues_count", 0),
+                )
+                results.append(repo)
+
+            return results
+
+    async def fetch_readme_snippet(self, owner: str, repo: str, max_chars: int = 800) -> Optional[str]:
+        """Fetch README content snippet for a repository."""
+        url = f"{GITHUB_API_BASE}/repos/{owner}/{repo}/readme"
+        headers = {**self.headers, "Accept": "application/vnd.github.v3.raw"}
+
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            try:
+                response = await client.get(url, headers=headers)
+                if response.status_code == 200:
+                    text = response.text
+                    cleaned = text.strip()
+                    return cleaned[:max_chars] + "..." if len(cleaned) > max_chars else cleaned
+            except Exception:
+                pass
+        return None
+
+    async def search_and_enrich(
+        self,
+        keywords: List[str],
+        topics: List[str] = None,
+        limit: int = 10,
+        fetch_readmes: bool = True
+    ) -> List[RepositoryInfo]:
+        """
+        Execute smart combined search using keywords & topics, deduplicate results,
+        and enrich top results with README snippets asynchronously.
+        """
+        all_repos: Dict[str, RepositoryInfo] = {}
+
+        queries = []
+        if keywords:
+            for kw in keywords:
+                kw_clean = kw.strip()
+                if kw_clean and kw_clean not in queries:
+                    queries.append(kw_clean)
+
+        if topics:
+            for topic in topics[:3]:
+                topic_clean = topic.strip().replace(" ", "-").lower()
+                if topic_clean and topic_clean not in ["python", "machine-learning", "deep-learning", "ai", "artificial-intelligence"]:
+                    t_query = f"topic:{topic_clean}"
+                    if t_query not in queries:
+                        queries.append(t_query)
+
+        tasks = [self.search_repositories(q, limit=limit) for q in queries]
+        search_results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        for res in search_results:
+            if isinstance(res, list):
+                for repo in res:
+                    if repo.full_name not in all_repos:
+                        all_repos[repo.full_name] = repo
+
+        sorted_repos = sorted(all_repos.values(), key=lambda r: (r.stars, r.forks, r.full_name), reverse=True)[:limit]
+
+        if fetch_readmes and sorted_repos:
+            readme_tasks = [
+                self.fetch_readme_snippet(repo.owner, repo.name)
+                for repo in sorted_repos[:5]
+            ]
+            readmes = await asyncio.gather(*readme_tasks, return_exceptions=True)
+            
+            for i, readme in enumerate(readmes):
+                if isinstance(readme, str) and readme:
+                    sorted_repos[i].readme_snippet = readme
+
+        return sorted_repos
+
+    def rank_and_sort_by_relevance(
+        self,
+        repos: List[RepositoryInfo],
+        limit: int = 10,
+        min_relevance: int = 50,
+    ) -> List[RepositoryInfo]:
+        """
+        Calculate hybrid score for each repository, filter out repos below min_relevance threshold,
+        and sort by hybrid score desc.
+        Hybrid Score = (Relevance Score * 0.7) + (Normalized Star Score * 0.3)
+        """
+        if not repos:
+            return repos
+
+        import math
+        max_stars = max((r.stars for r in repos), default=1)
+
+        for r in repos:
+            rel_score = r.relevance_score if r.relevance_score is not None else 50
+            star_score = min(100.0, (math.log10(r.stars + 1) / math.log10(max(max_stars, 10) + 1)) * 100.0) if max_stars > 0 else 50.0
+            r.hybrid_score = round((rel_score * 0.7) + (star_score * 0.3), 1)
+
+        # Enforce minimum relevance threshold filtering
+        filtered_repos = [
+            r for r in repos
+            if r.relevance_score is not None and r.relevance_score >= min_relevance
+        ]
+
+        if not filtered_repos:
+            fallback_threshold = max(30, min_relevance - 20)
+            filtered_repos = [
+                r for r in repos
+                if r.relevance_score is not None and r.relevance_score >= fallback_threshold
+            ]
+
+        sorted_repos = sorted(
+            filtered_repos if filtered_repos else repos,
+            key=lambda r: (r.hybrid_score, r.stars, r.forks, r.full_name),
+            reverse=True
+        )
+        return sorted_repos[:limit]

gitradar/services/llm.py

@@ -0,0 +1,342 @@
+import json
+import os
+import re
+from typing import List, Optional
+from openai import OpenAI, AuthenticationError, APIError, NotFoundError, BadRequestError
+from gitradar.config import settings
+from gitradar.models import ExpandedQueries, GapAnalysisReport, RepositoryInfo
+from gitradar.prompts import render_prompt
+
+
+def extract_json(content: str) -> dict:
+    """Extract and parse JSON object from LLM response text, handling markdown blocks or thought tags."""
+    if not content:
+        raise ValueError("Empty LLM response content received.")
+
+    cleaned = content.strip()
+
+    # Remove <think>...</think> block if present
+    cleaned = re.sub(r"<think>.*?</think>", "", cleaned, flags=re.DOTALL).strip()
+
+    # Remove markdown code blocks if wrapped in ```json ... ``` or ``` ... ```
+    if "```" in cleaned:
+        cleaned = re.sub(r"^```(?:json)?\s*", "", cleaned, flags=re.IGNORECASE)
+        cleaned = re.sub(r"\s*```$", "", cleaned)
+        cleaned = cleaned.strip()
+
+    # Find outer-most JSON bounds: first '{' and last '}'
+    start = cleaned.find("{")
+    end = cleaned.rfind("}")
+    if start != -1 and end != -1 and end > start:
+        cleaned = cleaned[start : end + 1].strip()
+
+    try:
+        return json.loads(cleaned)
+    except json.JSONDecodeError:
+        # Sanitize trailing commas: e.g. ", }" -> "}" or ", ]" -> "]"
+        sanitized = re.sub(r",\s*([\}\]])", r"\1", cleaned)
+        return json.loads(sanitized)
+
+
+class LLMService:
+    """Service to interact with OpenAI-compatible API endpoints for query expansion and gap analysis."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        model: Optional[str] = None,
+        language: Optional[str] = None,
+    ):
+        if api_key is not None:
+            self.api_key = api_key.strip().strip("'\"")
+        else:
+            raw_key = (
+                settings.openai_api_key
+                or os.environ.get("OPENAI_API_KEY")
+                or settings.groq_api_key
+                or os.environ.get("GROQ_API_KEY")
+                or ""
+            )
+            self.api_key = raw_key.strip().strip("'\"")
+
+        if base_url is not None:
+            raw_base_url = base_url
+        else:
+            raw_base_url = (
+                settings.openai_base_url
+                or os.environ.get("OPENAI_BASE_URL")
+                or os.environ.get("OPENAI_API_BASE")
+            )
+
+        if raw_base_url:
+            self.base_url = raw_base_url.strip().strip("'\"").rstrip("/")
+        elif self.api_key.startswith("gsk_"):
+            # Auto-detect Groq OpenAI-compatible endpoint for Groq keys
+            self.base_url = "https://api.groq.com/openai/v1"
+        elif api_key is None and not self.api_key and settings.groq_api_key:
+            # Fallback to Groq if only groq is configured
+            self.api_key = settings.groq_api_key.strip().strip("'\"")
+            self.base_url = "https://api.groq.com/openai/v1"
+        else:
+            self.base_url = None
+
+        # Local endpoints (Ollama, LM Studio, vLLM) may run without API keys
+        if self.base_url and any(h in self.base_url for h in ["localhost", "127.0.0.1", "0.0.0.0"]):
+            if not self.api_key:
+                self.api_key = "ollama"
+
+        raw_model = model or settings.default_model or "gpt-4o-mini"
+        if raw_model.startswith("groq/"):
+            raw_model = raw_model.replace("groq/", "", 1)
+
+        # If routed to Groq and model is OpenAI default, default to Groq's high-capability model
+        if self.base_url and "groq.com" in self.base_url and raw_model in ("gpt-4o-mini", "gpt-4o"):
+            raw_model = "llama-3.3-70b-versatile"
+
+        self.model = raw_model
+        self.language = language or settings.default_language
+        self._client: Optional[OpenAI] = None
+
+    @property
+    def client(self) -> OpenAI:
+        if self._client is None:
+            self._ensure_api_key()
+            effective_key = self.api_key or "no-key-required"
+            self._client = OpenAI(
+                api_key=effective_key,
+                base_url=self.base_url,
+                timeout=60.0,
+            )
+        return self._client
+
+    def _ensure_api_key(self):
+        # Local endpoints (Ollama, LM Studio, vLLM) may run without API keys
+        if self.base_url and any(h in self.base_url for h in ["localhost", "127.0.0.1", "0.0.0.0"]):
+            if not self.api_key:
+                self.api_key = "ollama"
+            return
+
+        if not self.api_key or self.api_key.strip() in ("", "sk-...", "gsk_...", "gsk_your_groq_api_key_here"):
+            raise ValueError(
+                "Missing AI API Key! Please configure OPENAI_API_KEY (or GROQ_API_KEY) in Settings (⚙️), "
+                "or run `gitradar config --openai-api-key YOUR_KEY`."
+            )
+
+    def _fetch_active_models(self) -> List[str]:
+        """Dynamically query the OpenAI-compatible endpoint for available models."""
+        try:
+            res = self.client.models.list()
+            models = [m.id for m in res.data]
+            text_models = [
+                m for m in models
+                if not any(x in m.lower() for x in ["whisper", "tts", "embedding", "dall-e", "guard", "moderation"])
+            ]
+            return text_models
+        except Exception:
+            return []
+
+    def _completion_with_fallback(self, messages: List[dict], temperature: float = 0.3) -> dict:
+        """Try primary model, fallback models, and handle JSON mode variations."""
+        candidates = [self.model]
+        if self.base_url and "groq.com" in self.base_url:
+            candidates.extend([
+                "llama-3.3-70b-versatile",
+                "llama-3.1-8b-instant",
+                "openai/gpt-oss-120b",
+                "qwen/qwen3.6-27b",
+            ])
+        else:
+            candidates.extend([
+                "gpt-4o-mini",
+                "gpt-4o",
+                "gpt-3.5-turbo",
+            ])
+
+        models_to_try = []
+        for m in candidates:
+            if m and m not in models_to_try:
+                models_to_try.append(m)
+
+        last_exception = None
+
+        for model_name in models_to_try:
+            # 1. First attempt: JSON object response format
+            try:
+                res = self.client.chat.completions.create(
+                    model=model_name,
+                    messages=messages,
+                    temperature=temperature,
+                    response_format={"type": "json_object"},
+                )
+                content = res.choices[0].message.content
+                return extract_json(content)
+            except AuthenticationError as ae:
+                raise ValueError(
+                    f"Authentication Failed with AI Provider ({self.base_url or 'OpenAI'}): Invalid API Key. "
+                    "Please update your key in Settings (⚙️) or via `gitradar config`."
+                ) from ae
+            except Exception as e:
+                err_str = str(e).lower()
+                if any(k in err_str for k in ["invalid_api_key", "incorrect api key", "unauthorized"]):
+                    raise ValueError(
+                        f"Authentication Failed with AI Provider ({self.base_url or 'OpenAI'}): Invalid API Key. "
+                        "Please update your key in Settings (⚙️) or via `gitradar config`."
+                    ) from e
+                last_exception = e
+
+            # 2. Second attempt: Plain text completion (fallback for providers without response_format support)
+            try:
+                res = self.client.chat.completions.create(
+                    model=model_name,
+                    messages=messages,
+                    temperature=temperature,
+                )
+                content = res.choices[0].message.content
+                return extract_json(content)
+            except AuthenticationError as ae:
+                raise ValueError(
+                    f"Authentication Failed with AI Provider ({self.base_url or 'OpenAI'}): Invalid API Key. "
+                    "Please update your key in Settings (⚙️) or via `gitradar config`."
+                ) from ae
+            except Exception as e:
+                err_str = str(e).lower()
+                if any(k in err_str for k in ["invalid_api_key", "incorrect api key", "unauthorized"]):
+                    raise ValueError(
+                        f"Authentication Failed with AI Provider ({self.base_url or 'OpenAI'}): Invalid API Key. "
+                        "Please update your key in Settings (⚙️) or via `gitradar config`."
+                    ) from e
+                last_exception = e
+                continue
+
+        if last_exception:
+            raise last_exception
+        raise RuntimeError("All model fallback attempts failed.")
+
+    def expand_idea_to_queries(self, idea: str, language: str = None) -> ExpandedQueries:
+        """Use LLM to generate search keywords and GitHub topics based on the project idea."""
+        self._ensure_api_key()
+        lang = language or self.language or settings.default_language
+
+        system_prompt = render_prompt("query_expansion_system", language=lang)
+        user_prompt = render_prompt("query_expansion_user", idea=idea)
+
+        data = self._completion_with_fallback(
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=0.0,
+        )
+
+        if not isinstance(data, dict):
+            data = {}
+
+        if "search_keywords" in data and not isinstance(data["search_keywords"], list):
+            data["search_keywords"] = [str(data["search_keywords"])]
+        if "github_topics" in data and not isinstance(data["github_topics"], list):
+            data["github_topics"] = [str(data["github_topics"])]
+
+        try:
+            return ExpandedQueries(**data)
+        except Exception:
+            return ExpandedQueries(
+                search_keywords=data.get("search_keywords") or [idea],
+                github_topics=data.get("github_topics") or [],
+                target_languages=data.get("target_languages") or [],
+                search_explanation=str(data.get("search_explanation") or "Search strategy generated."),
+            )
+
+    def analyze_market_and_gaps(self, idea: str, repositories: List[RepositoryInfo], language: str = None) -> GapAnalysisReport:
+        """Analyze market saturation, identify gaps, differentiators, and produce an analysis report."""
+        self._ensure_api_key()
+        lang = language or self.language or settings.default_language
+
+        system_prompt = render_prompt("gap_analysis_system", language=lang)
+        user_prompt = render_prompt("gap_analysis_user", idea=idea, repositories=repositories)
+
+        data = self._completion_with_fallback(
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=0.4,
+        )
+
+        if not isinstance(data, dict):
+            data = {}
+
+        for score_key in ("saturation_score", "opportunity_score"):
+            if score_key in data:
+                try:
+                    data[score_key] = int(data[score_key])
+                except (ValueError, TypeError):
+                    data[score_key] = 50
+
+        try:
+            return GapAnalysisReport(**data)
+        except Exception:
+            return GapAnalysisReport(
+                idea_summary=str(data.get("idea_summary") or idea),
+                market_saturation=str(data.get("market_saturation") or "Moderate"),
+                saturation_score=int(data.get("saturation_score") or 50),
+                market_summary=str(data.get("market_summary") or "Market analysis completed."),
+                unmet_needs=list(data.get("unmet_needs") or []),
+                differentiators=list(data.get("differentiators") or []),
+                actionable_recommendations=list(data.get("actionable_recommendations") or []),
+                opportunity_score=int(data.get("opportunity_score") or 80),
+            )
+
+    def evaluate_repository_relevance(
+        self,
+        idea: str,
+        repositories: List[RepositoryInfo],
+        language: str = None
+    ) -> List[RepositoryInfo]:
+        """Evaluate LLM relevance scores and fit reasons for a list of candidate repositories."""
+        if not repositories:
+            return repositories
+
+        try:
+            self._ensure_api_key()
+            target_lang = language or self.language or settings.default_language
+
+            sys_msg = render_prompt("relevance_evaluation_system", language=target_lang)
+            user_msg = render_prompt("relevance_evaluation_user", idea=idea, repos=repositories)
+
+            data = self._completion_with_fallback(
+                messages=[
+                    {"role": "system", "content": sys_msg},
+                    {"role": "user", "content": user_msg},
+                ],
+                temperature=0.0,
+            )
+
+            if isinstance(data, dict):
+                evals = data.get("evaluations", [])
+                eval_map = {item.get("full_name"): item for item in evals if isinstance(item, dict)}
+
+                for repo in repositories:
+                    if repo.full_name in eval_map:
+                        ev = eval_map[repo.full_name]
+                        score = ev.get("relevance_score")
+                        if isinstance(score, (int, float)):
+                            repo.relevance_score = max(0, min(100, int(score)))
+                        else:
+                            repo.relevance_score = 50
+                        repo.is_direct_competitor = bool(ev.get("is_direct_competitor", repo.relevance_score >= 60))
+                        repo.relevance_reason = str(ev.get("relevance_reason") or "Evaluated fit against project idea.")
+                    else:
+                        repo.relevance_score = 50
+                        repo.is_direct_competitor = True
+                        repo.relevance_reason = "Search candidate."
+        except Exception:
+            for repo in repositories:
+                if repo.relevance_score is None:
+                    repo.relevance_score = 50
+                repo.is_direct_competitor = True
+                if not repo.relevance_reason:
+                    repo.relevance_reason = "Keyword search match."
+
+        return repositories
+