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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reprompt-cli
-Version: 1.8.0
+Version: 1.8.1
 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.8.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reprompt-cli"
-version = "1.8.0"
+version = "1.8.1"
 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.8.1}/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.8.1"
 
 __all__ = [
     "__version__",

{reprompt_cli-1.8.0 → reprompt_cli-1.8.1}/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.8.1}/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.8.1/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.8.1}/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.8.1}/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.8.1/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.8.1}/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.1/tests/test_repetition.py

@@ -0,0 +1,124 @@
+"""Tests for cross-session prompt repetition detection."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from reprompt.core.repetition import analyze_repetition
+from reprompt.storage.db import PromptDB
+
+
+@pytest.fixture
+def db(tmp_path: Path) -> PromptDB:
+    return PromptDB(tmp_path / "test.db")
+
+
+def _insert(db: PromptDB, text: str, session_id: str, source: str = "claude-code") -> None:
+    db.insert_prompt(text, source=source, session_id=session_id, timestamp="2026-03-28T10:00:00Z")
+
+
+class TestAnalyzeRepetition:
+    def test_empty_db_returns_zero(self, db: PromptDB):
+        report = analyze_repetition(db)
+        assert report.total_prompts_analyzed == 0
+        assert report.repetition_rate == 0.0
+        assert report.recurring_topics == []
+
+    def test_single_session_no_cross_session(self, db: PromptDB):
+        """Similar prompts in the same session don't count as cross-session."""
+        _insert(db, "fix the authentication bug in login.py", "s1")
+        _insert(db, "fix the authentication issue in login module", "s1")
+        _insert(db, "fix the auth problem in the login file", "s1")
+        report = analyze_repetition(db)
+        assert report.repetition_rate == 0.0
+        assert len(report.recurring_topics) == 0
+
+    def test_cross_session_detected(self, db: PromptDB):
+        """Similar prompts across sessions form a recurring topic."""
+        _insert(db, "fix the authentication bug in login.py please", "s1")
+        _insert(db, "fix the authentication bug in login.py now", "s2")
+        report = analyze_repetition(db)
+        assert len(report.recurring_topics) >= 1
+        topic = report.recurring_topics[0]
+        assert topic.session_count >= 2
+        assert topic.total_matches >= 2
+        assert report.repetition_rate > 0
+
+    def test_unrelated_prompts_no_match(self, db: PromptDB):
+        """Completely different prompts don't cluster."""
+        _insert(db, "fix the authentication bug in login.py", "s1")
+        _insert(db, "add pagination to the user list API endpoint", "s2")
+        report = analyze_repetition(db)
+        assert report.repetition_rate == 0.0
+
+    def test_three_sessions_same_topic(self, db: PromptDB):
+        """Topic spanning 3 sessions gets session_count=3."""
+        _insert(db, "fix the authentication bug in login.py", "s1")
+        _insert(db, "fix the authentication issue in login module", "s2")
+        _insert(db, "fix auth problem in the login file", "s3")
+        report = analyze_repetition(db)
+        if report.recurring_topics:
+            topic = report.recurring_topics[0]
+            assert topic.session_count >= 2  # at least 2, ideally 3
+
+    def test_duplicate_of_excluded(self, db: PromptDB):
+        """Prompts marked as duplicates should be excluded."""
+        _insert(db, "fix the authentication bug in login.py", "s1")
+        _insert(db, "fix the authentication bug in login.py copy", "s2")
+        # Mark second as duplicate
+        conn = db._conn()
+        try:
+            conn.execute("UPDATE prompts SET duplicate_of = 1 WHERE session_id = 's2'")
+            conn.commit()
+        finally:
+            conn.close()
+        report = analyze_repetition(db)
+        assert report.total_prompts_analyzed == 1  # only the non-duplicate
+
+    def test_limit_caps_analysis(self, db: PromptDB):
+        """Limit parameter restricts how many prompts are analyzed."""
+        for i in range(10):
+            _insert(db, f"unique prompt number {i} about topic {i}", f"s{i}")
+        report = analyze_repetition(db, limit=5)
+        assert report.total_prompts_analyzed == 5
+
+    def test_sorted_by_session_count(self, db: PromptDB):
+        """Topics sorted by session_count descending."""
+        # Topic A: 3 sessions
+        _insert(db, "fix the authentication bug in login.py", "s1")
+        _insert(db, "fix the authentication issue in login module", "s2")
+        _insert(db, "fix the auth problem in login file", "s3")
+        # Topic B: 2 sessions (different topic)
+        _insert(db, "add comprehensive unit tests for the payment API", "s4")
+        _insert(db, "add unit tests for the payment API endpoint", "s5")
+        report = analyze_repetition(db)
+        if len(report.recurring_topics) >= 2:
+            assert (
+                report.recurring_topics[0].session_count >= report.recurring_topics[1].session_count
+            )
+
+    def test_source_filter(self, db: PromptDB):
+        """Source filter limits analysis to specific adapter."""
+        _insert(db, "fix the authentication bug in login.py", "s1", source="claude-code")
+        _insert(db, "fix the authentication issue in login", "s2", source="cursor")
+        report = analyze_repetition(db, source="claude-code")
+        assert report.total_prompts_analyzed == 1
+
+    def test_total_sessions_counted(self, db: PromptDB):
+        """Total sessions reflects distinct session count in scope."""
+        _insert(db, "prompt one about topic alpha", "s1")
+        _insert(db, "prompt two about topic beta", "s2")
+        _insert(db, "prompt three about topic gamma", "s3")
+        report = analyze_repetition(db)
+        assert report.total_sessions == 3
+
+    def test_report_fields_present(self, db: PromptDB):
+        """All RepetitionReport fields are accessible."""
+        report = analyze_repetition(db)
+        assert isinstance(report.total_prompts_analyzed, int)
+        assert isinstance(report.cross_session_matches, int)
+        assert isinstance(report.repetition_rate, float)
+        assert isinstance(report.recurring_topics, list)
+        assert isinstance(report.total_sessions, int)

reprompt_cli-1.8.1/tests/test_repetition_cli.py

@@ -0,0 +1,102 @@
+"""Tests for `reprompt repetition` CLI command."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from reprompt.cli import app
+
+runner = CliRunner()
+
+
+def _seed_db(tmp_path: Path) -> Path:
+    """Create a DB with cross-session similar prompts."""
+    from reprompt.storage.db import PromptDB
+
+    db_path = tmp_path / "test.db"
+    db = PromptDB(db_path)
+
+    # Topic A: auth bug across 2 sessions
+    db.insert_prompt(
+        "fix the authentication bug in login.py please",
+        source="claude-code",
+        session_id="s1",
+        timestamp="2026-03-01T10:00:00Z",
+    )
+    db.insert_prompt(
+        "fix the authentication bug in login.py now",
+        source="claude-code",
+        session_id="s2",
+        timestamp="2026-03-15T10:00:00Z",
+    )
+    # Unrelated prompt
+    db.insert_prompt(
+        "add pagination to the user list API endpoint",
+        source="claude-code",
+        session_id="s3",
+        timestamp="2026-03-20T10:00:00Z",
+    )
+    return db_path
+
+
+def test_repetition_no_data(tmp_path, monkeypatch):
+    db_path = tmp_path / "empty.db"
+    monkeypatch.setenv("REPROMPT_DB_PATH", str(db_path))
+    result = runner.invoke(app, ["repetition"])
+    assert result.exit_code == 0
+    assert "no cross-session" in result.output.lower()
+
+
+def test_repetition_no_data_json(tmp_path, monkeypatch):
+    db_path = tmp_path / "empty.db"
+    monkeypatch.setenv("REPROMPT_DB_PATH", str(db_path))
+    result = runner.invoke(app, ["repetition", "--json"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["repetition_rate"] == 0.0
+    assert data["recurring_topics"] == []
+
+
+def test_repetition_with_data(tmp_path, monkeypatch):
+    db_path = _seed_db(tmp_path)
+    monkeypatch.setenv("REPROMPT_DB_PATH", str(db_path))
+    result = runner.invoke(app, ["repetition"])
+    assert result.exit_code == 0
+
+
+def test_repetition_json_output(tmp_path, monkeypatch):
+    db_path = _seed_db(tmp_path)
+    monkeypatch.setenv("REPROMPT_DB_PATH", str(db_path))
+    result = runner.invoke(app, ["repetition", "--json"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "repetition_rate" in data
+    assert "recurring_topics" in data
+    assert "total_prompts_analyzed" in data
+
+
+def test_repetition_source_filter(tmp_path, monkeypatch):
+    db_path = _seed_db(tmp_path)
+    monkeypatch.setenv("REPROMPT_DB_PATH", str(db_path))
+    result = runner.invoke(app, ["repetition", "--source", "nonexistent", "--json"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["total_prompts_analyzed"] == 0
+
+
+def test_repetition_last_option(tmp_path, monkeypatch):
+    db_path = _seed_db(tmp_path)
+    monkeypatch.setenv("REPROMPT_DB_PATH", str(db_path))
+    result = runner.invoke(app, ["repetition", "--last", "2", "--json"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["total_prompts_analyzed"] <= 2
+
+
+def test_repetition_help():
+    result = runner.invoke(app, ["repetition", "--help"])
+    assert result.exit_code == 0
+    assert "recurring" in result.output.lower() or "repetition" in result.output.lower()