reprompt-cli 1.7.1__tar.gz → 1.8.0__tar.gz

{reprompt_cli-1.7.1 → reprompt_cli-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reprompt-cli
-Version: 1.7.1
+Version: 1.8.0
 Summary: Discover, analyze, and optimize your prompts from AI coding sessions
 Project-URL: Homepage, https://github.com/reprompt-dev/reprompt
 Project-URL: Repository, https://github.com/reprompt-dev/reprompt
@@ -185,7 +185,7 @@ reprompt install-hook               # adds post-session hook to Claude Code
 
 Capture prompts from ChatGPT, Claude.ai, and Gemini directly in your browser:
 
-1. **Install the extension** from [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn)
+1. **Install the extension** from [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn) or [Firefox Add-ons](https://addons.mozilla.org/addon/reprompt-cli/)
 2. **Connect to the CLI:** `reprompt install-extension`
 3. **Verify:** `reprompt extension-status`
 
@@ -236,6 +236,7 @@ reprompt lint --json                # machine-readable output
 
 - **Website:** [getreprompt.dev](https://getreprompt.dev)
 - **Chrome Extension:** [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn)
+- **Firefox Add-on:** [Firefox Add-ons](https://addons.mozilla.org/addon/reprompt-cli/)
 - **PyPI:** [reprompt-cli](https://pypi.org/project/reprompt-cli/)
 - **Changelog:** [CHANGELOG.md](CHANGELOG.md)
 - **Privacy:** [getreprompt.dev/privacy](https://getreprompt.dev/privacy)

{reprompt_cli-1.7.1 → reprompt_cli-1.8.0}/README.md

@@ -140,7 +140,7 @@ reprompt install-hook               # adds post-session hook to Claude Code
 
 Capture prompts from ChatGPT, Claude.ai, and Gemini directly in your browser:
 
-1. **Install the extension** from [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn)
+1. **Install the extension** from [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn) or [Firefox Add-ons](https://addons.mozilla.org/addon/reprompt-cli/)
 2. **Connect to the CLI:** `reprompt install-extension`
 3. **Verify:** `reprompt extension-status`
 
@@ -191,6 +191,7 @@ reprompt lint --json                # machine-readable output
 
 - **Website:** [getreprompt.dev](https://getreprompt.dev)
 - **Chrome Extension:** [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn)
+- **Firefox Add-on:** [Firefox Add-ons](https://addons.mozilla.org/addon/reprompt-cli/)
 - **PyPI:** [reprompt-cli](https://pypi.org/project/reprompt-cli/)
 - **Changelog:** [CHANGELOG.md](CHANGELOG.md)
 - **Privacy:** [getreprompt.dev/privacy](https://getreprompt.dev/privacy)

{reprompt_cli-1.7.1 → reprompt_cli-1.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reprompt-cli"
-version = "1.7.1"
+version = "1.8.0"
 description = "Discover, analyze, and optimize your prompts from AI coding sessions"
 readme = "README.md"
 license = { text = "MIT" }

{reprompt_cli-1.7.1 → reprompt_cli-1.8.0}/src/reprompt/__init__.py

@@ -1,6 +1,6 @@
 """reprompt — Discover, analyze, and evolve your best prompts from AI coding sessions."""
 
-__version__ = "1.7.0"
+__version__ = "1.8.0"
 
 __all__ = [
     "__version__",

{reprompt_cli-1.7.1 → reprompt_cli-1.8.0}/src/reprompt/cli.py

@@ -1856,7 +1856,7 @@ def _create_host_wrapper() -> Path:
     # Find the Python executable that has reprompt installed
     python_path = sys_mod.executable
 
-    wrapper_path.write_text(f"#!/bin/sh\nexec {python_path} -u -m reprompt.bridge.host\n")
+    wrapper_path.write_text(f'#!/bin/sh\nexec "{python_path}" -u -m reprompt.bridge.host\n')
     wrapper_path.chmod(wrapper_path.stat().st_mode | stat.S_IEXEC)
     return wrapper_path
 
@@ -1916,6 +1916,64 @@ def extension_status() -> None:
         console.print("  Last sync:         never")
 
 
+@app.command(rich_help_panel="Analyze")
+def sessions(
+    last: int = typer.Option(10, "--last", help="Show N most recent sessions"),
+    source: str = typer.Option(
+        None, "--source", "-s", help="Filter by source (e.g. claude-code, cursor)"
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    detail: str = typer.Option(None, "--detail", help="Deep-dive into a session ID"),
+    copy: bool = typer.Option(False, "--copy", help="Copy result to clipboard"),
+) -> None:
+    """Session quality overview: composite scores, frustration signals, trends."""
+    import json as json_mod
+
+    from reprompt.config import Settings
+    from reprompt.output.sessions_terminal import render_session_detail, render_sessions_table
+    from reprompt.storage.db import PromptDB
+
+    settings = Settings()
+    db = PromptDB(settings.db_path)
+
+    if detail:
+        # Single session detail view
+        all_sessions = db.get_sessions_with_quality(limit=500)
+        match = next((s for s in all_sessions if s.get("session_id") == detail), None)
+        if not match:
+            # Try prefix match
+            match = next(
+                (s for s in all_sessions if (s.get("session_id") or "").startswith(detail)),
+                None,
+            )
+        if not match:
+            typer.echo(f"Session '{detail}' not found.")
+            raise typer.Exit(1)
+        if json_output:
+            typer.echo(json_mod.dumps(match, indent=2, default=str))
+        else:
+            typer.echo(render_session_detail(match), nl=False)
+    else:
+        data = db.get_sessions_with_quality(limit=last, source=source)
+        if json_output:
+            typer.echo(json_mod.dumps(data, indent=2, default=str))
+        else:
+            typer.echo(render_sessions_table(data), nl=False)
+
+            from reprompt.core.suggestions import get_suggestion
+
+            hint = get_suggestion("sessions")
+            if hint:
+                console.print(f"\n  [dim]\u2192 Try: {hint}[/dim]")
+
+    if copy:
+        if detail:
+            copy_text = json_mod.dumps(match, indent=2, default=str)  # type: ignore[possibly-undefined]
+        else:
+            copy_text = json_mod.dumps(data, indent=2, default=str)  # type: ignore[possibly-undefined]
+        _copy_to_clip(copy_text, quiet=json_output)
+
+
 @app.command(rich_help_panel="Analyze")
 def agent(
     last: int = typer.Option(5, "--last", help="Analyze N most recent sessions"),

{reprompt_cli-1.7.1 → reprompt_cli-1.8.0}/src/reprompt/core/pipeline.py

@@ -185,6 +185,105 @@ def run_scan(
             except Exception:
                 logger.debug("Session metadata extraction failed for %s", file_path, exc_info=True)
 
+    # Compute session quality scores
+    from datetime import datetime
+
+    from reprompt.core.agent import analyze_session
+    from reprompt.core.conversation import Conversation
+    from reprompt.core.distill import distill_conversation
+    from reprompt.core.session_quality import score_session
+
+    quality_failures = 0
+    for file_path, adapter_name in scanned_files:
+        try:
+            matched = next((a for a in adapters if a.name == adapter_name), None)
+            if not matched:
+                continue
+
+            # parse_conversation returns list[ConversationTurn], wrap into Conversation
+            turns = matched.parse_conversation(Path(file_path))
+            if not turns:
+                continue
+
+            session_id = Path(file_path).stem
+            start_time = None
+            end_time = None
+            duration = None
+            timestamps = [t.timestamp for t in turns if t.timestamp]
+            if len(timestamps) >= 2:
+                start_time = timestamps[0]
+                end_time = timestamps[-1]
+                try:
+                    start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+                    end_dt = datetime.fromisoformat(end_time.replace("Z", "+00:00"))
+                    duration = int((end_dt - start_dt).total_seconds())
+                except (ValueError, TypeError):
+                    pass
+
+            project = None
+            if hasattr(matched, "_project_from_path"):
+                project = matched._project_from_path(file_path)
+
+            conversation = Conversation(
+                session_id=session_id,
+                source=adapter_name,
+                project=project,
+                turns=turns,
+                start_time=start_time,
+                end_time=end_time,
+                duration_seconds=duration,
+            )
+
+            # Agent analysis (efficiency, error loops)
+            agent_report = None
+            try:
+                agent_report = analyze_session(conversation)
+            except Exception:
+                logger.warning("Agent analysis failed for %s", file_path, exc_info=True)
+
+            # Distill analysis (focus/retention)
+            distill_result = None
+            try:
+                distill_result = distill_conversation(conversation)
+            except Exception:
+                logger.warning("Distill analysis failed for %s", file_path, exc_info=True)
+
+            # Avg prompt score from stored features
+            avg_prompt_score = None
+            scores = db.get_prompt_scores_for_session(session_id)
+            if scores:
+                avg_prompt_score = sum(scores) / len(scores)
+
+            # Effectiveness score from session_meta
+            effectiveness = db.get_effectiveness_for_session(session_id)
+
+            quality = score_session(
+                conversation,
+                agent_report=agent_report,
+                distill_result=distill_result,
+                effectiveness_score=effectiveness,
+                avg_prompt_score=avg_prompt_score,
+            )
+            db.upsert_session_quality(
+                session_id=quality.session_id,
+                quality_score=quality.quality_score,
+                prompt_quality_score=quality.prompt_quality,
+                efficiency_score=quality.efficiency,
+                focus_score=quality.focus,
+                outcome_score=quality.outcome,
+                has_abandonment=quality.frustration.abandonment,
+                has_escalation=quality.frustration.escalation,
+                stall_turns=quality.frustration.stall_turns,
+                session_type=quality.session_type,
+                quality_insight=quality.insight,
+            )
+        except Exception:
+            quality_failures += 1
+            logger.warning("Session quality scoring failed for %s", file_path, exc_info=True)
+
+    if quality_failures:
+        logger.warning("Quality scoring failed for %d session(s)", quality_failures)
+
     # Mark sessions processed only after successful dedup+store
     for file_path, adapter_name in scanned_files:
         db.mark_session_processed(file_path, source=adapter_name)

reprompt_cli-1.8.0/src/reprompt/core/session_quality.py

@@ -0,0 +1,203 @@
+"""Session-level quality metrics — composite scoring + frustration detection.
+
+Combines prompt quality, agent efficiency, distill focus, and outcome
+into a single 0-100 session score. All analysis is rule-based (zero LLM, <1ms).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from reprompt.core.agent import AgentReport
+from reprompt.core.conversation import Conversation, ConversationTurn, DistillResult
+
+# ---------------------------------------------------------------------------
+# Component weights (must sum to 1.0)
+# ---------------------------------------------------------------------------
+
+DEFAULT_WEIGHTS: dict[str, float] = {
+    "prompt_quality": 0.30,
+    "efficiency": 0.30,
+    "focus": 0.20,
+    "outcome": 0.20,
+}
+
+
+# ---------------------------------------------------------------------------
+# Dataclasses
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class FrustrationSignals:
+    """Frustration indicators detected from conversation turns."""
+
+    abandonment: bool = False  # Last 3+ assistant turns all have errors
+    escalation: bool = False  # Error rate in second half > first half * 1.5
+    stall_turns: int = 0  # Assistant turns with 0 tool calls and <50 chars
+
+
+@dataclass
+class SessionQuality:
+    """Composite session quality report."""
+
+    session_id: str
+    quality_score: float  # 0-100 composite
+    prompt_quality: float | None = None  # 0-100
+    efficiency: float | None = None  # 0-100
+    focus: float | None = None  # 0-100
+    outcome: float | None = None  # 0-100
+    frustration: FrustrationSignals = field(default_factory=FrustrationSignals)
+    session_type: str | None = None
+    insight: str = ""
+    components_available: int = 0
+
+
+# ---------------------------------------------------------------------------
+# Frustration detection
+# ---------------------------------------------------------------------------
+
+
+def _detect_frustration(turns: list[ConversationTurn]) -> FrustrationSignals:
+    """Detect frustration signals from conversation turns."""
+    asst_turns = [t for t in turns if t.role == "assistant"]
+
+    if not asst_turns:
+        return FrustrationSignals()
+
+    # Abandonment: last 3+ assistant turns all have errors
+    abandonment = False
+    if len(asst_turns) >= 3:
+        last_three = asst_turns[-3:]
+        abandonment = all(t.has_error for t in last_three)
+
+    # Escalation: error rate in second half > first half * 1.5
+    escalation = False
+    if len(asst_turns) >= 4:
+        mid = len(asst_turns) // 2
+        first_half = asst_turns[:mid]
+        second_half = asst_turns[mid:]
+        first_rate = sum(1 for t in first_half if t.has_error) / len(first_half)
+        second_rate = sum(1 for t in second_half if t.has_error) / len(second_half)
+        escalation = second_rate > first_rate * 1.5 and second_rate > 0.2
+
+    # Stall turns: assistant turns with no tool calls and short text
+    stall_turns = sum(
+        1 for t in asst_turns if t.tool_calls == 0 and len(t.text.strip()) < 50
+    )
+
+    return FrustrationSignals(
+        abandonment=abandonment,
+        escalation=escalation,
+        stall_turns=stall_turns,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Insight generation
+# ---------------------------------------------------------------------------
+
+
+def _generate_insight(quality: SessionQuality) -> str:
+    """Generate a one-line insight from quality metrics (priority order)."""
+    f = quality.frustration
+
+    if f.abandonment:
+        return "Ended with unresolved errors"
+
+    if f.escalation:
+        return "Errors escalated through session"
+
+    if f.stall_turns >= 5:
+        return f"{f.stall_turns} stall turns detected"
+
+    if quality.efficiency is not None and quality.efficiency < 50:
+        return "Low efficiency (error loops)"
+
+    score = quality.quality_score
+    if score >= 80:
+        return "Focused session"
+    if score >= 60:
+        return "Solid session"
+    if score >= 40:
+        return "Room for improvement"
+    return "Rough session"
+
+
+# ---------------------------------------------------------------------------
+# Main scoring function
+# ---------------------------------------------------------------------------
+
+
+def score_session(
+    conversation: Conversation,
+    *,
+    agent_report: AgentReport | None = None,
+    distill_result: DistillResult | None = None,
+    effectiveness_score: float | None = None,
+    avg_prompt_score: float | None = None,
+) -> SessionQuality:
+    """Compute composite session quality score (0-100).
+
+    Components (weighted average of available inputs):
+    - prompt_quality (30%): avg overall_score from prompt features
+    - efficiency (30%): productive_ratio from agent analysis
+    - focus (20%): retention_ratio from distill
+    - outcome (20%): effectiveness_score
+
+    When a component is unavailable, its weight redistributes proportionally.
+    """
+    components: dict[str, float] = {}
+
+    # Prompt quality: already 0-100
+    if avg_prompt_score is not None:
+        components["prompt_quality"] = max(0.0, min(100.0, avg_prompt_score))
+
+    # Efficiency: productive_ratio is 0-1
+    if agent_report is not None:
+        ratio = agent_report.efficiency.productive_ratio
+        components["efficiency"] = max(0.0, min(100.0, ratio * 100))
+
+    # Focus: retention_ratio is 0-1
+    if distill_result is not None:
+        ratio = distill_result.stats.retention_ratio
+        components["focus"] = max(0.0, min(100.0, ratio * 100))
+
+    # Outcome: effectiveness_score is 0-1
+    if effectiveness_score is not None:
+        components["outcome"] = max(0.0, min(100.0, effectiveness_score * 100))
+
+    # Compute weighted average with weight redistribution
+    if components:
+        available_weights = {k: DEFAULT_WEIGHTS[k] for k in components}
+        weight_sum = sum(available_weights.values())
+        normalized = {k: w / weight_sum for k, w in available_weights.items()}
+        quality_score = sum(components[k] * normalized[k] for k in components)
+    else:
+        quality_score = 0.0
+
+    quality_score = round(max(0.0, min(100.0, quality_score)), 1)
+
+    # Frustration detection
+    frustration = _detect_frustration(conversation.turns)
+
+    # Session type
+    session_type_str: str | None = None
+    if agent_report is not None and agent_report.efficiency.session_type is not None:
+        session_type_str = agent_report.efficiency.session_type
+
+    quality = SessionQuality(
+        session_id=conversation.session_id,
+        quality_score=quality_score,
+        prompt_quality=components.get("prompt_quality"),
+        efficiency=components.get("efficiency"),
+        focus=components.get("focus"),
+        outcome=components.get("outcome"),
+        frustration=frustration,
+        session_type=session_type_str,
+        components_available=len(components),
+    )
+
+    quality.insight = _generate_insight(quality)
+
+    return quality

{reprompt_cli-1.7.1 → reprompt_cli-1.8.0}/src/reprompt/core/suggestions.py

@@ -15,6 +15,9 @@ SUGGESTIONS: dict[str, str] = {
     "agent": (
         "reprompt agent --loops-only (error loops) · reprompt privacy --deep (sensitive content)"
     ),
+    "sessions": (
+        "reprompt sessions --detail <id> (deep-dive) · reprompt agent (error loop analysis)"
+    ),
     "template": "reprompt insights (see which patterns work best)",
 }
 

reprompt_cli-1.8.0/src/reprompt/output/sessions_terminal.py

@@ -0,0 +1,172 @@
+"""Rich terminal rendering for session quality metrics."""
+
+from __future__ import annotations
+
+from io import StringIO
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+
+def _score_style(score: float | None) -> str:
+    """Return Rich style string for a quality score."""
+    if score is None:
+        return "dim"
+    if score >= 80:
+        return "green"
+    if score >= 60:
+        return "yellow"
+    if score >= 40:
+        return "dim"
+    return "red"
+
+
+def _fmt_score(score: float | None) -> str:
+    if score is None:
+        return "—"
+    return f"{score:.0f}"
+
+
+def _fmt_duration(seconds: int | None) -> str:
+    if seconds is None:
+        return "—"
+    if seconds < 60:
+        return f"{seconds}s"
+    return f"{seconds // 60}min"
+
+
+def _bar(value: float, width: int = 10) -> str:
+    """Render a 0-100 value as a bar chart."""
+    filled = max(0, min(width, round(value / 100 * width)))
+    return "\u2588" * filled + "\u2591" * (width - filled)
+
+
+def render_sessions_table(sessions: list[dict[str, Any]]) -> str:
+    """Render session quality overview as formatted terminal output."""
+    console = Console(record=True, width=100, file=StringIO())
+
+    if not sessions:
+        console.print("[dim]No sessions with quality scores found.[/dim]")
+        console.print(
+            "Run [bold cyan]reprompt scan[/bold cyan] to import and score sessions."
+        )
+        return console.export_text()
+
+    # Compute avg quality
+    scored = [s for s in sessions if s.get("quality_score") is not None]
+    avg_q = sum(s["quality_score"] for s in scored) / len(scored) if scored else 0
+
+    # Header
+    header = (
+        f"Sessions: {len(sessions)}  |  "
+        f"Scored: {len(scored)}  |  "
+        f"Avg Quality: {avg_q:.0f}/100"
+    )
+    console.print(Panel(header, title="Session Quality", border_style="cyan"))
+
+    # Table
+    table = Table(show_header=True, header_style="bold", padding=(0, 1))
+    table.add_column("Session", max_width=20)
+    table.add_column("Score", justify="right", width=5)
+    table.add_column("Type", width=6)
+    table.add_column("Turns", justify="right", width=5)
+    table.add_column("Errors", justify="right", width=6)
+    table.add_column("Duration", justify="right", width=8)
+    table.add_column("Insight", max_width=30)
+
+    for s in sessions:
+        score = s.get("quality_score")
+        style = _score_style(score)
+        sid = (s.get("session_id") or "")[:20]
+        stype = (s.get("session_type") or "")[:6]
+        turns = str(s.get("prompt_count") or "—")
+        errors = str(s.get("error_count") or "0")
+        duration = _fmt_duration(s.get("duration_seconds"))
+        insight = s.get("quality_insight") or ""
+
+        table.add_row(
+            sid,
+            f"[{style}]{_fmt_score(score)}[/{style}]",
+            stype,
+            turns,
+            errors,
+            duration,
+            insight,
+        )
+
+    console.print(table)
+    console.print()
+    return console.export_text()
+
+
+def render_session_detail(session: dict[str, Any]) -> str:
+    """Render a single session's quality breakdown."""
+    console = Console(record=True, width=100, file=StringIO())
+
+    sid = session.get("session_id", "unknown")
+    score = session.get("quality_score")
+    style = _score_style(score)
+
+    console.print(
+        Panel(
+            f"Session: {sid}  |  Score: [{style}]{_fmt_score(score)}/100[/{style}]",
+            title="Session Detail",
+            border_style="cyan",
+        )
+    )
+
+    # Component scores
+    console.print()
+    console.print("  [bold]Quality Components[/bold]")
+    console.print("  \u2500" * 50)
+
+    components = [
+        ("Prompt Quality", session.get("prompt_quality_score"), "30%"),
+        ("Efficiency", session.get("efficiency_score"), "30%"),
+        ("Focus", session.get("focus_score"), "20%"),
+        ("Outcome", session.get("outcome_score"), "20%"),
+    ]
+
+    for name, val, weight in components:
+        if val is not None:
+            bar = _bar(val)
+            cs = _score_style(val)
+            console.print(f"  {name:<16} {bar}  [{cs}]{val:.0f}[/{cs}]  (weight: {weight})")
+        else:
+            console.print(f"  {name:<16} [dim]not available[/dim]  (weight: {weight})")
+
+    # Frustration signals
+    console.print()
+    console.print("  [bold]Frustration Signals[/bold]")
+    console.print("  \u2500" * 50)
+
+    signals = []
+    if session.get("has_abandonment"):
+        signals.append("[red]Abandonment[/red] — session ended with unresolved errors")
+    if session.get("has_escalation"):
+        signals.append("[red]Escalation[/red] — errors increased through session")
+    stalls = session.get("stall_turns", 0)
+    if stalls > 0:
+        signals.append(f"[yellow]Stall turns[/yellow] — {stalls} turns with no tool use")
+
+    if signals:
+        for sig in signals:
+            console.print(f"  \u26a0 {sig}")
+    else:
+        console.print("  [green]None detected[/green]")
+
+    # Session info
+    console.print()
+    console.print("  [bold]Session Info[/bold]")
+    console.print("  \u2500" * 50)
+    console.print(f"  Source: {session.get('source', '—')}")
+    console.print(f"  Type: {session.get('session_type') or '—'}")
+    console.print(f"  Duration: {_fmt_duration(session.get('duration_seconds'))}")
+    console.print(f"  Prompts: {session.get('prompt_count', '—')}")
+    console.print(f"  Errors: {session.get('error_count', 0)}")
+    console.print(f"  Insight: {session.get('quality_insight') or '—'}")
+
+    console.print()
+    return console.export_text()