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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reprompt-cli
-Version: 1.8.0
+Version: 1.9.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

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

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

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

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

reprompt_cli-1.9.0/src/reprompt/bridge/handler.py

@@ -0,0 +1,234 @@
+"""Message handler for Native Messaging bridge.
+
+Processes incoming messages from the browser extension:
+- ping -> pong (health check)
+- sync_prompts -> store in DB, return counts + lightweight insights
+- get_status -> return DB stats
+- get_insights -> return full analysis (repetition, patterns, top insight)
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from typing import Any
+
+from reprompt import __version__
+from reprompt.adapters.filters import should_keep_prompt
+from reprompt.storage.db import PromptDB
+
+logger = logging.getLogger(__name__)
+
+
+def handle_message(message: dict[str, Any], db: PromptDB) -> dict[str, Any]:
+    """Process a single message and return a response dict."""
+    msg_type = message.get("type", "")
+
+    if msg_type == "ping":
+        return {"type": "pong", "version": __version__}
+
+    if msg_type == "sync_prompts":
+        return _handle_sync(message, db)
+
+    if msg_type == "get_status":
+        return _handle_status(db)
+
+    if msg_type == "get_insights":
+        return _handle_insights(message, db)
+
+    return {"type": "error", "message": f"Unknown message type: {msg_type}"}
+
+
+def _handle_sync(message: dict[str, Any], db: PromptDB) -> dict[str, Any]:
+    """Store synced prompts in DB, skipping noise and duplicates."""
+    prompts = message.get("prompts", [])
+    received = len(prompts)
+    new_stored = 0
+    duplicates = 0
+
+    for p in prompts:
+        text = p.get("text", "").strip()
+        if not should_keep_prompt(text):
+            continue
+
+        source = p.get("source", "extension")
+        session_id = p.get("conversation_id", "")
+        project = p.get("conversation_title", "")
+        timestamp = p.get("timestamp", "")
+
+        inserted = db.insert_prompt(
+            text,
+            source=source,
+            project=project,
+            session_id=session_id,
+            timestamp=timestamp,
+        )
+        if inserted:
+            new_stored += 1
+        else:
+            duplicates += 1
+
+    # Record last sync time
+    _update_last_sync(db)
+
+    return {
+        "type": "sync_result",
+        "received": received,
+        "new_stored": new_stored,
+        "duplicates": duplicates,
+        "insights": _compute_quick_insights(db),
+    }
+
+
+def _handle_status(db: PromptDB) -> dict[str, Any]:
+    """Return current database stats."""
+    stats = db.get_stats()
+    return {
+        "type": "status",
+        "total_prompts": stats.get("total_prompts", 0),
+        "last_sync": _get_last_sync(db),
+        "version": __version__,
+    }
+
+
+def _handle_insights(message: dict[str, Any], db: PromptDB) -> dict[str, Any]:
+    """Return full analysis: repetition, effectiveness patterns, insights.
+
+    Heavier computation than sync — call on-demand, not every sync.
+    """
+    source = message.get("source")
+    result: dict[str, Any] = {"type": "insights_result"}
+
+    try:
+        from reprompt.core.insights import (
+            compute_insights,
+            get_cross_session_repetition_insight,
+            get_effectiveness_insight,
+        )
+
+        features = db.get_all_features(source=source)
+        if features:
+            full = compute_insights(features)
+            result["avg_score"] = full.get("avg_score", 0.0)
+            result["prompt_count"] = full.get("prompt_count", 0)
+            result["score_distribution"] = full.get("score_distribution", {})
+            result["insights"] = [
+                {"category": i["category"], "action": i["action"], "impact": i["impact"]}
+                for i in full.get("insights", [])
+            ]
+        else:
+            result["avg_score"] = 0.0
+            result["prompt_count"] = 0
+            result["score_distribution"] = {}
+            result["insights"] = []
+
+        # Repetition (may be None if insufficient data)
+        rep = get_cross_session_repetition_insight(db, source=source)
+        if rep:
+            result["repetition"] = {
+                "rate": rep["repetition_rate"],
+                "top_topics": rep["top_topics"],
+                "total_recurring": rep["total_recurring_topics"],
+            }
+
+        # Effectiveness patterns (may be None)
+        eff = get_effectiveness_insight(db, source=source)
+        if eff:
+            result["effectiveness"] = {
+                "top_patterns": eff["top_patterns"],
+                "total_patterns": eff["total_patterns"],
+            }
+
+    except Exception:
+        logger.warning("Failed to compute full insights for extension", exc_info=True)
+        result["error"] = "Failed to compute insights"
+
+    return result
+
+
+def _compute_quick_insights(db: PromptDB) -> dict[str, Any]:
+    """Lightweight stats for extension display. Pure SQL, no heavy computation."""
+    stats = db.get_stats()
+    total = stats.get("total_prompts", 0)
+
+    if total == 0:
+        return {
+            "avg_score": 0.0,
+            "total_prompts": 0,
+            "score_trend": "stable",
+            "top_insight": None,
+        }
+
+    scores = db.get_recent_scores(limit=50)
+
+    if not scores:
+        return {
+            "avg_score": 0.0,
+            "total_prompts": total,
+            "score_trend": "stable",
+            "top_insight": None,
+        }
+
+    avg_score = round(sum(scores) / len(scores), 1)
+
+    # Trend: compare first half (recent) vs second half (older)
+    mid = len(scores) // 2
+    if mid >= 5:
+        recent_avg = sum(scores[:mid]) / mid
+        older_avg = sum(scores[mid:]) / (len(scores) - mid)
+        diff = recent_avg - older_avg
+        if diff > 3:
+            trend = "improving"
+        elif diff < -3:
+            trend = "declining"
+        else:
+            trend = "stable"
+    else:
+        trend = "stable"
+
+    # Top insight: get highest-impact actionable tip
+    top_insight = _get_top_insight(db)
+
+    return {
+        "avg_score": avg_score,
+        "total_prompts": total,
+        "score_trend": trend,
+        "top_insight": top_insight,
+    }
+
+
+def _get_top_insight(db: PromptDB) -> str | None:
+    """Return the single most impactful insight as a string, or None."""
+    try:
+        from reprompt.core.insights import compute_insights
+
+        features = db.get_all_features()
+        if len(features) < 5:
+            return None
+        result = compute_insights(features)
+        insights = result.get("insights", [])
+        # Prioritize high-impact insights
+        for impact in ("high", "medium", "low"):
+            for i in insights:
+                if i.get("impact") == impact:
+                    return i["action"]
+    except Exception:
+        logger.debug("Failed to compute top insight", exc_info=True)
+    return None
+
+
+def _update_last_sync(db: PromptDB) -> None:
+    """Store last sync timestamp in the DB settings table."""
+    now_ts = str(int(datetime.now(tz=timezone.utc).timestamp()))
+    db.set_setting("last_extension_sync", now_ts)
+
+
+def _get_last_sync(db: PromptDB) -> str:
+    """Get last sync timestamp. Returns empty string if never synced."""
+    val = db.get_setting("last_extension_sync")
+    if val:
+        try:
+            return datetime.fromtimestamp(int(val), tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        except (ValueError, OSError):
+            return ""
+    return ""

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

@@ -1474,6 +1474,7 @@ def insights(
     from reprompt.config import Settings
     from reprompt.core.insights import (
         compute_insights,
+        get_cross_session_repetition_insight,
         get_effectiveness_insight,
         get_similar_prompts_insight,
     )
@@ -1487,12 +1488,14 @@ def insights(
     # Expanded sections
     eff_data = get_effectiveness_insight(db, source=source)
     sim_data = get_similar_prompts_insight(db, source=source)
+    rep_data = get_cross_session_repetition_insight(db, source=source)
 
     if json_output:
         import json as json_mod
 
         result["effectiveness"] = eff_data
         result["similar_prompts"] = sim_data
+        result["cross_session_repetition"] = rep_data
         typer.echo(json_mod.dumps(result, indent=2))
     else:
         from reprompt.core.suggestions import get_suggestion
@@ -1516,6 +1519,15 @@ def insights(
                 '  [dim]\u2192 Try: reprompt template save "..." (reuse instead of rewrite)[/dim]'
             )
 
+        if rep_data:
+            rate_pct = f"{rep_data['repetition_rate'] * 100:.0f}%"
+            n = rep_data["total_recurring_topics"]
+            console.print("\n  [bold]Cross-Session Repetition[/bold]")
+            console.print(f"  {rate_pct} of prompts recur across sessions ({n} topics)")
+            for t in rep_data["top_topics"]:
+                console.print(f'    "{t["canonical_text"]}" \u2014 {t["session_count"]} sessions')
+            console.print("  [dim]\u2192 Try: reprompt repetition (full analysis)[/dim]")
+
         hint = get_suggestion("insights")
         if hint:
             console.print(f"\n  [dim]\u2192 Try: {hint}[/dim]")
@@ -1525,6 +1537,7 @@ def insights(
 
         result["effectiveness"] = eff_data
         result["similar_prompts"] = sim_data
+        result["cross_session_repetition"] = rep_data
         _copy_to_clip(json_mod.dumps(result, indent=2), quiet=json_output)
 
 
@@ -1974,6 +1987,44 @@ def sessions(
         _copy_to_clip(copy_text, quiet=json_output)
 
 
+@app.command(rich_help_panel="Analyze")
+def repetition(
+    last: int = typer.Option(500, "--last", help="Analyze N most recent unique prompts"),
+    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"),
+    copy: bool = typer.Option(False, "--copy", help="Copy result to clipboard"),
+) -> None:
+    """Detect recurring prompts across different sessions."""
+    import json as json_mod
+    from dataclasses import asdict
+
+    from reprompt.config import Settings
+    from reprompt.core.repetition import analyze_repetition
+    from reprompt.output.repetition_terminal import render_repetition_report
+    from reprompt.storage.db import PromptDB
+
+    settings = Settings()
+    db = PromptDB(settings.db_path)
+    report = analyze_repetition(db, source=source, limit=last)
+
+    if json_output:
+        typer.echo(json_mod.dumps(asdict(report), indent=2, default=str))
+    else:
+        typer.echo(render_repetition_report(report), nl=False)
+
+        from reprompt.core.suggestions import get_suggestion
+
+        hint = get_suggestion("repetition")
+        if hint:
+            console.print(f"\n  [dim]\u2192 Try: {hint}[/dim]")
+
+    if copy:
+        copy_text = json_mod.dumps(asdict(report), indent=2, default=str)
+        _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.8.0 → reprompt_cli-1.9.0}/src/reprompt/core/insights.py

@@ -293,3 +293,29 @@ def get_similar_prompts_insight(
         "total_clusters": len(clusters),
         "total_clustered_prompts": sum(c["size"] for c in clusters),
     }
+
+
+def get_cross_session_repetition_insight(
+    db: PromptDB,
+    source: str | None = None,
+) -> dict[str, Any] | None:
+    """Return cross-session repetition summary, or None if no recurring topics."""
+    from reprompt.core.repetition import analyze_repetition
+
+    report = analyze_repetition(db, source=source, limit=500)
+
+    if not report.recurring_topics:
+        return None
+
+    return {
+        "repetition_rate": report.repetition_rate,
+        "top_topics": [
+            {
+                "canonical_text": t.canonical_text[:80],
+                "session_count": t.session_count,
+                "total_matches": t.total_matches,
+            }
+            for t in report.recurring_topics[:3]
+        ],
+        "total_recurring_topics": len(report.recurring_topics),
+    }

reprompt_cli-1.9.0/src/reprompt/core/repetition.py

@@ -0,0 +1,128 @@
+"""Cross-session prompt repetition detection.
+
+Identifies recurring topics asked across different AI coding sessions
+using TF-IDF + containment similarity clustering. All analysis is
+rule-based (zero LLM).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from reprompt.storage.db import PromptDB
+
+
+@dataclass
+class RecurringTopic:
+    """A topic that recurs across multiple sessions."""
+
+    canonical_text: str
+    session_count: int
+    total_matches: int
+    session_ids: list[str] = field(default_factory=list)
+    earliest: str = ""
+    latest: str = ""
+
+
+@dataclass
+class RepetitionReport:
+    """Result of cross-session repetition analysis."""
+
+    total_prompts_analyzed: int = 0
+    cross_session_matches: int = 0
+    repetition_rate: float = 0.0  # cross_session_matches / total
+    recurring_topics: list[RecurringTopic] = field(default_factory=list)
+    total_sessions: int = 0
+
+
+def analyze_repetition(
+    db: PromptDB,
+    source: str | None = None,
+    limit: int = 500,
+    threshold: float = 0.75,
+) -> RepetitionReport:
+    """Detect recurring prompts across different sessions.
+
+    Reuses merge_view.build_clusters() for similarity, then filters
+    to clusters spanning 2+ distinct sessions.
+    """
+    from reprompt.core.merge_view import build_clusters
+
+    all_prompts = db.get_all_prompts(source=source)
+
+    # Filter to unique prompts only
+    unique = [p for p in all_prompts if p.get("duplicate_of") is None]
+
+    if not unique:
+        return RepetitionReport()
+
+    # Limit to most recent N (by id desc), then reverse for chronological
+    unique.sort(key=lambda p: p.get("id", 0), reverse=True)
+    unique = unique[:limit]
+    unique.reverse()
+
+    # Build lookup: text → prompt dict (safe due to hash uniqueness)
+    text_to_prompt: dict[str, dict[str, Any]] = {}
+    for p in unique:
+        text_to_prompt[p["text"]] = p
+
+    texts = [p["text"] for p in unique]
+    timestamps = [p.get("timestamp", "") for p in unique]
+    all_session_ids = {p.get("session_id") or "unknown" for p in unique}
+
+    # Build clusters using existing infrastructure
+    clusters = build_clusters(texts, timestamps, threshold=threshold)
+
+    # Filter to cross-session clusters
+    recurring: list[RecurringTopic] = []
+    total_cross_matches = 0
+
+    for cluster in clusters:
+        # Collect all texts in cluster (canonical + members)
+        cluster_texts = [cluster["canonical"]["text"]]
+        cluster_texts.extend(m["text"] for m in cluster["members"])
+
+        # Map to session_ids
+        sids: list[str] = []
+        cluster_timestamps: list[str] = []
+        for t in cluster_texts:
+            prompt = text_to_prompt.get(t)
+            if prompt:
+                sids.append(prompt.get("session_id") or "unknown")
+                cluster_timestamps.append(prompt.get("timestamp", ""))
+
+        distinct_sessions = sorted(set(sids))
+        if len(distinct_sessions) < 2:
+            continue
+
+        # Build timestamps for range
+        valid_ts = sorted(t for t in cluster_timestamps if t)
+        earliest = valid_ts[0] if valid_ts else ""
+        latest = valid_ts[-1] if valid_ts else ""
+
+        recurring.append(
+            RecurringTopic(
+                canonical_text=cluster["canonical"]["text"],
+                session_count=len(distinct_sessions),
+                total_matches=len(cluster_texts),
+                session_ids=distinct_sessions,
+                earliest=earliest,
+                latest=latest,
+            )
+        )
+        total_cross_matches += len(cluster_texts)
+
+    # Sort by session_count desc, then total_matches desc
+    recurring.sort(key=lambda t: (-t.session_count, -t.total_matches))
+
+    total = len(unique)
+    rate = total_cross_matches / total if total > 0 else 0.0
+
+    return RepetitionReport(
+        total_prompts_analyzed=total,
+        cross_session_matches=total_cross_matches,
+        repetition_rate=round(rate, 3),
+        recurring_topics=recurring,
+        total_sessions=len(all_session_ids),
+    )

{reprompt_cli-1.8.0 → reprompt_cli-1.9.0}/src/reprompt/core/session_quality.py

@@ -82,9 +82,7 @@ def _detect_frustration(turns: list[ConversationTurn]) -> FrustrationSignals:
         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
-    )
+    stall_turns = sum(1 for t in asst_turns if t.tool_calls == 0 and len(t.text.strip()) < 50)
 
     return FrustrationSignals(
         abandonment=abandonment,

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

@@ -18,6 +18,9 @@ SUGGESTIONS: dict[str, str] = {
     "sessions": (
         "reprompt sessions --detail <id> (deep-dive) · reprompt agent (error loop analysis)"
     ),
+    "repetition": (
+        'reprompt template save "..." (reuse patterns) · reprompt insights (all patterns)'
+    ),
     "template": "reprompt insights (see which patterns work best)",
 }
 

reprompt_cli-1.9.0/src/reprompt/output/repetition_terminal.py

@@ -0,0 +1,61 @@
+"""Rich terminal rendering for cross-session repetition analysis."""
+
+from __future__ import annotations
+
+from io import StringIO
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from reprompt.core.repetition import RepetitionReport
+
+
+def render_repetition_report(report: RepetitionReport) -> str:
+    """Render repetition report as formatted terminal output."""
+    console = Console(record=True, width=100, file=StringIO())
+
+    if not report.recurring_topics:
+        console.print("[dim]No cross-session repetition detected.[/dim]")
+        console.print(
+            "This means your prompts across sessions are unique — no recurring patterns found."
+        )
+        return console.export_text()
+
+    rate_pct = f"{report.repetition_rate * 100:.0f}%"
+    header = (
+        f"Prompts: {report.total_prompts_analyzed}  |  "
+        f"Sessions: {report.total_sessions}  |  "
+        f"Repetition Rate: {rate_pct}"
+    )
+    console.print(Panel(header, title="Cross-Session Repetition", border_style="cyan"))
+
+    # Table of recurring topics
+    table = Table(show_header=True, header_style="bold", padding=(0, 1))
+    table.add_column("Topic", max_width=45)
+    table.add_column("Sessions", justify="right", width=8)
+    table.add_column("Matches", justify="right", width=7)
+    table.add_column("Range", max_width=25)
+
+    for topic in report.recurring_topics[:10]:
+        text = topic.canonical_text
+        if len(text) > 45:
+            text = text[:42] + "..."
+
+        date_range = ""
+        if topic.earliest and topic.latest:
+            start = topic.earliest[:10]
+            end = topic.latest[:10]
+            date_range = f"{start} \u2192 {end}" if start != end else start
+
+        table.add_row(
+            text,
+            str(topic.session_count),
+            str(topic.total_matches),
+            date_range,
+        )
+
+    console.print(table)
+    console.print()
+
+    return console.export_text()

{reprompt_cli-1.8.0 → reprompt_cli-1.9.0}/src/reprompt/output/sessions_terminal.py

@@ -49,9 +49,7 @@ def render_sessions_table(sessions: list[dict[str, Any]]) -> str:
 
     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."
-        )
+        console.print("Run [bold cyan]reprompt scan[/bold cyan] to import and score sessions.")
         return console.export_text()
 
     # Compute avg quality
@@ -59,11 +57,7 @@ def render_sessions_table(sessions: list[dict[str, Any]]) -> str:
     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"
-    )
+    header = f"Sessions: {len(sessions)}  |  Scored: {len(scored)}  |  Avg Quality: {avg_q:.0f}/100"
     console.print(Panel(header, title="Session Quality", border_style="cyan"))
 
     # Table

{reprompt_cli-1.8.0 → reprompt_cli-1.9.0}/src/reprompt/storage/db.py

@@ -964,6 +964,23 @@ class PromptDB:
         finally:
             conn.close()
 
+    def get_recent_scores(self, limit: int = 50) -> list[float]:
+        """Return recent prompt scores ordered by timestamp (newest first)."""
+        conn = self._conn()
+        try:
+            rows = conn.execute(
+                """SELECT pf.overall_score
+                   FROM prompt_features pf
+                   JOIN prompts p ON pf.prompt_hash = p.hash
+                   WHERE pf.overall_score IS NOT NULL
+                   ORDER BY p.timestamp DESC
+                   LIMIT ?""",
+                (limit,),
+            ).fetchall()
+            return [r["overall_score"] for r in rows]
+        finally:
+            conn.close()
+
     def get_all_features(self, source: str | None = None) -> list[dict[str, Any]]:
         """Return all stored feature vectors, optionally filtered by source."""
         conn = self._conn()