gitradar 0.1.5__py3-none-any.whl

gitradar/utils/ui.py

@@ -0,0 +1,196 @@
+from typing import List
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.columns import Columns
+from rich.markdown import Markdown
+from gitradar import __version__
+from gitradar.models import ExpandedQueries, GapAnalysisReport, RepositoryInfo
+
+console = Console()
+
+
+def display_banner() -> None:
+    """Print stylish GitRadar terminal banner."""
+    banner_text = Text()
+    banner_text.append("📡 ", style="bold cyan")
+    banner_text.append("GitRadar", style="bold white on blue")
+    banner_text.append("  CLI Market & Gap Analysis Tool  ", style="bold cyan")
+    banner_text.append(f"[v{__version__}]", style="dim italic white")
+
+    console.print()
+    console.print(Panel(banner_text, border_style="cyan", expand=False))
+    console.print()
+
+
+def display_query_strategy(queries: ExpandedQueries) -> None:
+    """Display the AI generated search query expansion strategy."""
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_column("Key", style="bold yellow")
+    table.add_column("Value", style="cyan")
+
+    table.add_row("🔍 Search Keywords:", ", ".join(queries.search_keywords))
+    if queries.github_topics:
+        table.add_row("🏷️ GitHub Topics:", ", ".join(f"#{t}" for t in queries.github_topics))
+    if queries.target_languages:
+        table.add_row("💻 Target Languages:", ", ".join(queries.target_languages))
+    table.add_row("💡 Search Strategy:", queries.search_explanation)
+
+    console.print(
+        Panel(
+            table,
+            title="[bold green]🧠 LLM Search Strategy Generated[/bold green]",
+            border_style="green",
+            expand=True,
+        )
+    )
+    console.print()
+
+
+def display_repo_table(repositories: List[RepositoryInfo], title: str = "Relevant GitHub Repositories Found") -> None:
+    """Display repositories in a Rich styled table."""
+    if not repositories:
+        console.print("[bold red]No relevant repositories found.[/bold red]")
+        return
+
+    table = Table(
+        title=f"📊 {title} ({len(repositories)} Repos)",
+        header_style="bold magenta",
+        border_style="dim white",
+        expand=True,
+    )
+
+    table.add_column("#", justify="center", style="dim", width=3)
+    table.add_column("Repository", style="bold cyan", no_wrap=True)
+    table.add_column("Relevance 🎯", justify="center", style="bold")
+    table.add_column("Stars ⭐", justify="right", style="bold yellow")
+    table.add_column("Forks 🍴", justify="right", style="dim cyan")
+    table.add_column("Language 💻", style="green")
+    table.add_column("Last Updated 📅", justify="center", style="dim")
+    table.add_column("Description & Match Fit", style="white")
+
+    for idx, repo in enumerate(repositories, 1):
+        desc = repo.description or ""
+        if len(desc) > 50:
+            desc = desc[:47] + "..."
+
+        if repo.relevance_reason:
+            desc += f"\n[dim italic]Fit: {repo.relevance_reason}[/dim italic]"
+
+        rel_badge = "N/A"
+        if repo.relevance_score is not None:
+            if repo.relevance_score >= 80:
+                rel_badge = f"[bold green]🎯 {repo.relevance_score}% Match[/bold green]"
+            elif repo.relevance_score >= 50:
+                rel_badge = f"[bold yellow]⚡ {repo.relevance_score}% Match[/bold yellow]"
+            else:
+                rel_badge = f"[bold red]⚠️ {repo.relevance_score}% Match[/bold red]"
+
+        table.add_row(
+            str(idx),
+            f"[{repo.html_url}]{repo.full_name}[/]",
+            rel_badge,
+            f"{repo.stars:,}",
+            f"{repo.forks:,}",
+            repo.language or "N/A",
+            repo.updated_at or "N/A",
+            desc,
+        )
+
+    console.print(table)
+    console.print()
+
+
+def display_gap_report(report: GapAnalysisReport) -> None:
+    """Display comprehensive Market & Gap Analysis Report in terminal UI."""
+    console.print()
+    console.print("[bold cyan]════════════════════════════════════════════════════════════════════════════════[/bold cyan]")
+    console.print("  🎯 [bold white on blue] MARKET & GAP ANALYSIS REPORT [/bold white on blue]")
+    console.print("[bold cyan]════════════════════════════════════════════════════════════════════════════════[/bold cyan]")
+    console.print()
+
+    # 1. Summary & Market Saturation Gauge
+    sat_color = "green" if report.market_saturation in ["Düşük", "Low"] else ("yellow" if report.market_saturation in ["Orta", "Moderate"] else "red")
+    
+    summary_text = (
+        f"[bold white]Project Idea Summary:[/bold white] {report.idea_summary}\n\n"
+        f"[bold white]Market Saturation:[/bold white] [{sat_color}]{report.market_saturation}[/{sat_color}] "
+        f"(Saturation Score: [bold]{report.saturation_score}/100[/bold]) | "
+        f"[bold white]Opportunity Score:[/bold white] [bold green]{report.opportunity_score}/100 🚀[/bold green]\n\n"
+        f"[bold white]Market Summary:[/bold white]\n{report.market_summary}"
+    )
+    console.print(Panel(summary_text, title="[bold yellow]📌 Market Overview & Saturation Gauge[/bold yellow]", border_style=sat_color))
+    console.print()
+
+    # 2. Key Competitors
+    if report.top_competitors:
+        comp_table = Table(title="🏆 Top Competitors & Analysis", header_style="bold blue", expand=True)
+        comp_table.add_column("Competitor Repo", style="bold cyan", width=25)
+        comp_table.add_column("Key Strengths", style="green")
+        comp_table.add_column("Weaknesses & Gaps", style="red")
+
+        for comp in report.top_competitors:
+            strengths = "\n".join(f"• {s}" for s in comp.key_strengths)
+            weaknesses = "\n".join(f"• {w}" for w in comp.weaknesses_or_gaps)
+            comp_table.add_row(comp.repo_name, strengths, weaknesses)
+
+        console.print(comp_table)
+        console.print()
+
+    # 3. Unmet Needs & Differentiators
+    unmet_md = "### 🚨 Unmet Needs & Ecosystem Gaps\n"
+    for gap in report.unmet_needs:
+        unmet_md += f"- ❌ **{gap}**\n"
+
+    diff_md = "### 💎 Key Differentiators\n"
+    for diff in report.differentiators:
+        diff_md += f"- ✨ **{diff}**\n"
+
+    console.print(
+        Columns(
+            [
+                Panel(Markdown(unmet_md), border_style="red", title="[bold red]Unmet Needs (Gaps)[/bold red]", expand=True),
+                Panel(Markdown(diff_md), border_style="green", title="[bold green]Key Differentiators[/bold green]", expand=True),
+            ],
+            equal=True,
+        )
+    )
+    console.print()
+
+    # 4. Actionable Recommendations
+    rec_md = "### 💡 Strategic Developer Recommendations\n"
+    for idx, rec in enumerate(report.actionable_recommendations, 1):
+        rec_md += f"**{idx}.** {rec}\n"
+
+    console.print(Panel(Markdown(rec_md), title="[bold cyan]🛠️ Action Plan & Recommendations[/bold cyan]", border_style="cyan"))
+    console.print()
+
+    # 5. Technical Implementation Guide & Open Source Building Blocks
+    if report.implementation_guide:
+        guide = report.implementation_guide
+        guide_md = ""
+        if guide.recommended_tech_stack:
+            techs = ", ".join(f"`{t}`" for t in guide.recommended_tech_stack)
+            guide_md += f"**Recommended Tech Stack:** {techs}\n\n"
+        if guide.architecture_overview:
+            guide_md += f"**Architecture Overview:**\n{guide.architecture_overview}\n\n"
+
+        if guide.open_source_building_blocks:
+            guide_md += "### 📦 Recommended Open-Source Building Blocks\n"
+            for tool in guide.open_source_building_blocks:
+                link_str = f" ([link]({tool.repo_url}))" if tool.repo_url else ""
+                guide_md += f"- **{tool.name}** `[{tool.category}]`{link_str}: {tool.description_and_usage}\n"
+
+        console.print(Panel(Markdown(guide_md), title="[bold magenta]⚙️ Technical Implementation & Open-Source Roadmap[/bold magenta]", border_style="magenta"))
+        console.print()
+
+
+def display_error(message: str) -> None:
+    """Print an error panel."""
+    console.print(Panel(f"[bold red]ERROR:[/bold red] {message}", title="❌ Operation Failed", border_style="red"))
+
+
+def display_info(message: str) -> None:
+    """Print an info callout."""
+    console.print(f"[bold blue]ℹ️ {message}[/bold blue]")

gitradar/web/__init__.py

@@ -0,0 +1,7 @@
+"""
+GitRadar Web Dashboard Module.
+"""
+
+from .app import create_app
+
+__all__ = ["create_app"]

gitradar/web/app.py

@@ -0,0 +1,173 @@
+import asyncio
+import concurrent.futures
+from pathlib import Path
+from flask import Flask, render_template, request, jsonify, send_from_directory
+from gitradar.config import settings
+from gitradar.services.github import GitHubService
+from gitradar.services.llm import LLMService
+
+BASE_DIR = Path(__file__).parent
+
+
+def safe_run_async(coro):
+    """Run an async coroutine safely, handling cases where an asyncio event loop is already running (e.g. Vercel / ASGI)."""
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = None
+
+    if loop and loop.is_running():
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+            return executor.submit(asyncio.run, coro).result()
+    else:
+        return asyncio.run(coro)
+
+
+def create_app() -> Flask:
+    """Create and configure the Flask web application instance."""
+    app = Flask(
+        __name__,
+        template_folder=str(BASE_DIR / "templates"),
+        static_folder=str(BASE_DIR / "static"),
+    )
+
+    @app.route("/")
+    def index():
+        return render_template("index.html")
+
+    @app.route("/<path:filename>")
+    def serve_static_root(filename):
+        target = BASE_DIR / "static" / filename
+        if target.is_file():
+            return send_from_directory(BASE_DIR / "static", filename)
+        return jsonify({"error": "Not found"}), 404
+
+    @app.route("/api/config", methods=["GET"])
+    def get_config():
+        return jsonify({
+            "openai_configured": bool(settings.openai_api_key or settings.groq_api_key),
+            "groq_configured": bool(settings.groq_api_key),
+            "github_configured": bool(settings.github_token),
+            "default_model": settings.default_model,
+            "default_language": settings.default_language,
+            "max_repos_to_analyze": settings.max_repos_to_analyze,
+            "base_url": settings.openai_base_url,
+        })
+
+    @app.route("/api/analyze", methods=["POST"])
+    def analyze_idea():
+        data = request.get_json() or {}
+        idea = data.get("idea", "").strip()
+        limit = int(data.get("limit", 10))
+        model = data.get("model") or settings.default_model
+        language = data.get("language") or settings.default_language
+
+        def clean_key(v):
+            if not v:
+                return None
+            cleaned = str(v).replace("\r", "").replace("\n", "").replace("\t", "").strip().strip("'\"")
+            return cleaned if cleaned else None
+
+        # Extract user credentials and OpenAI-compatible endpoint from headers or JSON payload
+        api_key = clean_key(
+            request.headers.get("X-OpenAI-Api-Key")
+            or request.headers.get("X-Groq-Api-Key")
+            or data.get("openai_key")
+            or data.get("openaiKey")
+            or data.get("api_key")
+            or data.get("groq_key")
+            or data.get("groqKey")
+            or settings.openai_api_key
+            or settings.groq_api_key
+        )
+        base_url = clean_key(
+            request.headers.get("X-OpenAI-Base-Url")
+            or data.get("base_url")
+            or data.get("baseUrl")
+            or settings.openai_base_url
+        )
+        github_token = clean_key(
+            request.headers.get("X-Github-Token")
+            or data.get("github_token")
+            or data.get("githubToken")
+            or settings.github_token
+        )
+
+        if not idea:
+            return jsonify({"error": "Project idea parameter is required."}), 400
+
+        try:
+            llm_service = LLMService(api_key=api_key, base_url=base_url, model=model, language=language)
+            github_service = GitHubService(token=github_token)
+
+            # 1. Expand Queries
+            queries = llm_service.expand_idea_to_queries(idea, language=language)
+
+            # 2. Search GitHub Repositories
+            raw_repos = safe_run_async(
+                github_service.search_and_enrich(
+                    keywords=queries.search_keywords,
+                    topics=queries.github_topics,
+                    limit=max(limit * 2, 15),
+                )
+            )
+
+            try:
+                min_relevance = int(data.get("min_relevance") or data.get("minRelevance") or settings.min_relevance_threshold)
+            except (ValueError, TypeError):
+                min_relevance = settings.min_relevance_threshold
+
+            # 3. Relevance Evaluation & Hybrid Ranking
+            eval_repos = llm_service.evaluate_repository_relevance(idea, raw_repos, language=language)
+            repos = github_service.rank_and_sort_by_relevance(eval_repos, limit=limit, min_relevance=min_relevance)
+
+            # 4. Perform Gap Analysis
+            report = llm_service.analyze_market_and_gaps(idea, repos, language=language)
+
+            return jsonify({
+                "queries": queries.model_dump(),
+                "repositories": [r.model_dump() for r in repos],
+                "report": report.model_dump(),
+            })
+
+        except ValueError as ve:
+            return jsonify({"error": str(ve)}), 400
+        except Exception as e:
+            err_msg = str(e)
+            if any(k in err_msg.lower() for k in ["invalid_api_key", "invalid api key", "authentication", "unauthorized"]):
+                err_msg = "Invalid AI API Key! Please click the Settings Modal (⚙️) in the top-right corner and enter a valid API Key."
+            return jsonify({"error": err_msg}), 400
+
+    @app.route("/api/search", methods=["POST"])
+    def search_repos():
+        data = request.get_json() or {}
+        query = data.get("query", "").strip()
+        limit = int(data.get("limit", 10))
+        sort = data.get("sort", "stars")
+
+        def clean_key(v):
+            if not v:
+                return None
+            cleaned = str(v).replace("\r", "").replace("\n", "").replace("\t", "").strip().strip("'\"")
+            return cleaned if cleaned else None
+
+        github_token = clean_key(
+            request.headers.get("X-Github-Token")
+            or data.get("github_token")
+            or data.get("githubToken")
+            or settings.github_token
+        )
+
+        if not query:
+            return jsonify({"error": "Search query parameter is required."}), 400
+
+        try:
+            github_service = GitHubService(token=github_token)
+            repos = safe_run_async(github_service.search_repositories(query, limit=limit, sort=sort))
+            return jsonify({
+                "repositories": [r.model_dump() for r in repos]
+            })
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
+    return app