ragcheck-cli 0.2.5__tar.gz → 0.2.7__tar.gz

{ragcheck_cli-0.2.5/ragcheck_cli.egg-info → ragcheck_cli-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragcheck-cli
-Version: 0.2.5
+Version: 0.2.7
 Summary: Lighthouse for RAG systems - diagnose and fix your retrieval pipeline
 Author-email: Pranay Mane <pranaymane78@gmail.com>
 License: MIT

{ragcheck_cli-0.2.5 → ragcheck_cli-0.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ragcheck-cli"
-version = "0.2.5"
+version = "0.2.7"
 description = "Lighthouse for RAG systems - diagnose and fix your retrieval pipeline"
 readme = "README.md"
 license = {text = "MIT"}

{ragcheck_cli-0.2.5 → ragcheck_cli-0.2.7}/ragcheck/__init__.py

@@ -1,3 +1,3 @@
-"""ragcheck — Lighthouse for RAG systems."""
-
-__version__ = "0.2.5"
+"""ragcheck — Lighthouse for RAG systems."""
+
+__version__ = "0.2.7"

{ragcheck_cli-0.2.5 → ragcheck_cli-0.2.7}/ragcheck/analyzers/failure_classifier.py

@@ -161,6 +161,40 @@ class FailureClassifier:
         # paraphrased answers from small local models like phi3:mini
         return overlap_ratio > 0.15 or phrase_ratio > 0.20
 
+    def classify_batch(self, details: list[dict]) -> list[dict]:
+        """Classify a batch of retrieval results (CLI compatibility).
+
+        Args:
+            details: List of detail dicts from RetrievalTester.test()
+
+        Returns:
+            List of failure dicts for the report.
+        """
+        failures = []
+        for detail in details:
+            if not detail.get("hit", False):
+                # Build fake Chunk objects from retrieved texts
+                retrieved_texts = detail.get("retrieved", [])
+                retrieved_chunks = [Chunk(text=t) for t in retrieved_texts]
+                source_chunks = detail.get("source_chunks", [])
+                if not source_chunks and detail.get("expected"):
+                    source_chunks = [detail["expected"]]
+
+                analysis = self.classify(
+                    question=detail.get("question", ""),
+                    expected_answer=detail.get("expected", ""),
+                    generated_answer="",
+                    retrieved_chunks=retrieved_chunks,
+                    source_chunks=source_chunks,
+                )
+                failures.append({
+                    "mode": analysis.failure_mode.value,
+                    "confidence": int(analysis.confidence * 100),
+                    "explanation": analysis.explanation,
+                    "question": detail.get("question", ""),
+                    "description": analysis.explanation,
+                })
+        return failures
     def _is_boundary_error(self, expected: str, chunks: list[str]) -> bool:
         """Detect if answer is split across chunk boundaries."""
         chunk_positions = []

{ragcheck_cli-0.2.5 → ragcheck_cli-0.2.7}/ragcheck/analyzers/recommender.py

@@ -174,3 +174,50 @@ def predict_scores(
         "improvement": cumulative_improvement,
         "recommendations_applied": len(recommendations[:3]),
     }
+
+
+class Recommender:
+    """Compatibility wrapper for CLI — wraps RecommendationEngine."""
+
+    def __init__(self, config=None):
+        self.engine = RecommendationEngine()
+        self.config = config
+
+    def recommend(self, failures: list) -> list[dict]:
+        """Generate recommendations from failure analyses.
+
+        Accepts either FailureAnalysis objects or raw dicts.
+        """
+        from ragcheck.analyzers.failure_classifier import FailureAnalysis, FailureMode
+
+        analyses = []
+        for f in failures:
+            if isinstance(f, FailureAnalysis):
+                analyses.append(f)
+            elif isinstance(f, dict):
+                # Convert dict to FailureAnalysis
+                mode_str = f.get("mode", "unknown")
+                try:
+                    mode = FailureMode(mode_str)
+                except ValueError:
+                    mode = FailureMode.UNKNOWN
+                analyses.append(FailureAnalysis(
+                    failure_mode=mode,
+                    confidence=f.get("confidence", 50) / 100.0,
+                    explanation=f.get("explanation", ""),
+                    recommendation=f.get("recommendation", ""),
+                    expected_improvement=0.05,
+                ))
+
+        recs = self.engine.generate_recommendations(analyses)
+        return [
+            {
+                "title": r.title,
+                "description": r.description,
+                "expected_improvement": r.expected_improvement,
+                "tradeoffs": r.tradeoffs,
+                "difficulty": r.implementation_difficulty,
+                "code_example": r.code_example,
+            }
+            for r in recs
+        ]

{ragcheck_cli-0.2.5 → ragcheck_cli-0.2.7}/ragcheck/cli.py

@@ -176,7 +176,7 @@ To use a real LLM:
     # Analyze failures
     progress.start("Analyzing failures...")
     classifier = FailureClassifier(config)
-    failures = classifier.classify(retrieval_results["details"])
+    failures = classifier.classify_batch(retrieval_results["details"])
 
     recommender = Recommender(config)
     recommendations = recommender.recommend(failures)
@@ -208,7 +208,7 @@ To use a real LLM:
     # Summary
     score = retrieval_results["score"]
     color = "green" if score >= 80 else "yellow" if score >= 60 else "red"
-    console.print(f"\n[{color}]Tests: {retrieval_results['passed']}/{retrieval_results['total']} passed | Score: {score}%[/[{color}]]")
+    console.print(f"\n[{color}]Tests: {retrieval_results['passed']}/{retrieval_results['total']} passed | Score: {score}%[/]")
 
 
     if score < 100:

ragcheck_cli-0.2.7/ragcheck/core/progress.py

@@ -0,0 +1,72 @@
+"""Rich progress tracking for ragcheck operations."""
+
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,
+)
+
+console = Console()
+
+
+def get_progress() -> Progress:
+    """Get a pre-configured Rich Progress instance."""
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+        TimeElapsedColumn(),
+        TimeRemainingColumn(),
+        console=console,
+    )
+
+
+def print_success(message: str) -> None:
+    """Print a success message."""
+    console.print(f"[bold green]OK[/bold green] {message}")
+
+
+def print_warning(message: str) -> None:
+    """Print a warning message."""
+    console.print(f"[bold yellow]⚠[/bold yellow] {message}")
+
+
+def print_error(message: str) -> None:
+    """Print an error message."""
+    console.print(f"[bold red]✗[/bold red] {message}")
+
+
+class Progress:
+    """Simple progress wrapper for CLI compatibility."""
+
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self._task = None
+        self._rich_progress = None
+
+    def start(self, message: str) -> None:
+        """Start a new progress task."""
+        if self.verbose:
+            console.print(f"[dim]→ {message}[/dim]")
+        self._rich_progress = get_progress()
+        self._task = self._rich_progress.add_task(message, total=100)
+        self._rich_progress.start()
+
+    def update(self, message: str) -> None:
+        """Update progress message."""
+        if self._rich_progress and self._task is not None:
+            self._rich_progress.update(self._task, description=message)
+
+    def complete(self, message: str) -> None:
+        """Complete the current task."""
+        if self._rich_progress and self._task is not None:
+            self._rich_progress.update(self._task, completed=100)
+            self._rich_progress.stop()
+            self._rich_progress = None
+            self._task = None
+        print_success(message)

{ragcheck_cli-0.2.5 → ragcheck_cli-0.2.7}/ragcheck/reports/html_report.py

@@ -354,8 +354,7 @@ class HTMLReport:
                 is_hit = detail.get("hit", False)
                 cell_class = "cell-good" if is_hit else "cell-dead"
                 val = "1" if is_hit else "0"
-                html += f'<div class="heatmap-cell {cell_class}">{val}</div>
-'
+                html += f'<div class="heatmap-cell {cell_class}">{val}</div>\n'
         return html
 
     def _build_failures(self, failures: List[Dict]) -> str:
@@ -511,3 +510,49 @@ class HTMLReport:
     def _build_chunk_details(self, chunks: List[Any]) -> str:
         """Build detailed chunk view."""
         return ""
+
+
+def generate_report(
+    project_name: str,
+    overall_score: float | None,
+    retrieval_score: float | None,
+    faithfulness_score: float | None,
+    tests_passed: int,
+    tests_total: int,
+    failures: list[dict],
+    recommendations: list[dict],
+    current_score: float | None,
+    predicted_score: float | None,
+    chunk_strategy: str,
+    num_chunks: int,
+    chunk_histogram: list[dict],
+    chunk_details: list[dict],
+    avg_chunk_length: float,
+    context_loss_score: float,
+    heatmap_data: list[dict],
+) -> str:
+    """Generate HTML report from test results (compatibility wrapper).
+
+    Delegates to HTMLReport.generate() for consistent output.
+    """
+    from ragcheck.core.config import Config
+
+    config = Config()
+    reporter = HTMLReport(config)
+
+    # Build data dict matching HTMLReport.generate() expectations
+    data = {
+        "project_name": project_name,
+        "retrieval_results": {
+            "score": (overall_score * 100) if overall_score is not None else 0,
+            "passed": tests_passed,
+            "total": tests_total,
+            "details": [],
+        },
+        "chunks": [],
+        "failures": failures,
+        "recommendations": recommendations,
+        "config": config,
+    }
+
+    return reporter.generate(data)

{ragcheck_cli-0.2.5 → ragcheck_cli-0.2.7/ragcheck_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragcheck-cli
-Version: 0.2.5
+Version: 0.2.7
 Summary: Lighthouse for RAG systems - diagnose and fix your retrieval pipeline
 Author-email: Pranay Mane <pranaymane78@gmail.com>
 License: MIT

ragcheck_cli-0.2.5/ragcheck/analyzers/__init__.py

@@ -1 +0,0 @@
-"""Analyzers for ragcheck."""

ragcheck_cli-0.2.5/ragcheck/core/__init__.py

@@ -1 +0,0 @@
-"""Core utilities for ragcheck."""

ragcheck_cli-0.2.5/ragcheck/core/progress.py

@@ -1,41 +0,0 @@
-"""Rich progress tracking for ragcheck operations."""
-
-from rich.console import Console
-from rich.progress import (
-    BarColumn,
-    Progress,
-    SpinnerColumn,
-    TextColumn,
-    TimeElapsedColumn,
-    TimeRemainingColumn,
-)
-
-console = Console()
-
-
-def get_progress() -> Progress:
-    """Get a pre-configured Rich Progress instance."""
-    return Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        BarColumn(),
-        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
-        TimeElapsedColumn(),
-        TimeRemainingColumn(),
-        console=console,
-    )
-
-
-def print_success(message: str) -> None:
-    """Print a success message."""
-    console.print(f"[bold green]OK[/bold green] {message}")
-
-
-def print_warning(message: str) -> None:
-    """Print a warning message."""
-    console.print(f"[bold yellow]⚠[/bold yellow] {message}")
-
-
-def print_error(message: str) -> None:
-    """Print an error message."""
-    console.print(f"[bold red]✗[/bold red] {message}")

ragcheck_cli-0.2.5/ragcheck/reports/__init__.py

@@ -1 +0,0 @@
-"""Report generation for ragcheck."""

ragcheck_cli-0.2.5/ragcheck/testers/__init__.py

@@ -1 +0,0 @@
-"""Test generation and retrieval testing for ragcheck."""