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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "reprompt-cli"
-version = "1.8.1"
+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.1 → 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.1"
+__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.1 → 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()

{reprompt_cli-1.8.1 → reprompt_cli-1.9.0}/tests/test_bridge_e2e.py

@@ -129,25 +129,25 @@ class TestExtensionE2EPipeline:
         # Verify ping
         assert responses[0]["type"] == "pong"
 
-        # Verify sync results
-        assert responses[1] == {
-            "type": "sync_result",
-            "received": 2,
-            "new_stored": 2,
-            "duplicates": 0,
-        }
-        assert responses[2] == {
-            "type": "sync_result",
-            "received": 1,
-            "new_stored": 1,
-            "duplicates": 0,
-        }
-        assert responses[3] == {
-            "type": "sync_result",
-            "received": 1,
-            "new_stored": 1,
-            "duplicates": 0,
-        }
+        # Verify sync results (check core fields; insights key added in v1.9)
+        r1 = responses[1]
+        assert r1["type"] == "sync_result"
+        assert r1["received"] == 2
+        assert r1["new_stored"] == 2
+        assert r1["duplicates"] == 0
+        assert "insights" in r1
+
+        r2 = responses[2]
+        assert r2["type"] == "sync_result"
+        assert r2["received"] == 1
+        assert r2["new_stored"] == 1
+        assert r2["duplicates"] == 0
+
+        r3 = responses[3]
+        assert r3["type"] == "sync_result"
+        assert r3["received"] == 1
+        assert r3["new_stored"] == 1
+        assert r3["duplicates"] == 0
 
         # Verify status shows all 4 prompts
         assert responses[4]["type"] == "status"

reprompt_cli-1.9.0/tests/test_bridge_handler.py

@@ -0,0 +1,354 @@
+"""Tests for Native Messaging message handler."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from reprompt.bridge.handler import handle_message
+from reprompt.storage.db import PromptDB
+
+
+def test_handle_ping(tmp_path: Path) -> None:
+    db = PromptDB(tmp_path / "test.db")
+    response = handle_message({"type": "ping"}, db)
+    assert response["type"] == "pong"
+    assert "version" in response
+
+
+def test_handle_sync_prompts(tmp_path: Path) -> None:
+    db = PromptDB(tmp_path / "test.db")
+    msg = {
+        "type": "sync_prompts",
+        "prompts": [
+            {
+                "text": "Explain how async/await works in Python",
+                "source": "chatgpt-ext",
+                "timestamp": "2026-03-15T10:00:00Z",
+                "conversation_id": "conv-001",
+                "conversation_title": "Python async",
+            },
+            {
+                "text": "Show me a simple example of asyncio.gather",
+                "source": "chatgpt-ext",
+                "timestamp": "2026-03-15T10:01:00Z",
+                "conversation_id": "conv-001",
+                "conversation_title": "Python async",
+            },
+        ],
+    }
+    response = handle_message(msg, db)
+    assert response["type"] == "sync_result"
+    assert response["received"] == 2
+    assert response["new_stored"] == 2
+    assert response["duplicates"] == 0
+
+
+def test_handle_sync_dedup(tmp_path: Path) -> None:
+    """Second sync of same prompts should report duplicates."""
+    db = PromptDB(tmp_path / "test.db")
+    msg = {
+        "type": "sync_prompts",
+        "prompts": [
+            {
+                "text": "Explain how async/await works in Python",
+                "source": "chatgpt-ext",
+                "timestamp": "2026-03-15T10:00:00Z",
+                "conversation_id": "conv-001",
+                "conversation_title": "Python async",
+            },
+        ],
+    }
+    handle_message(msg, db)
+    response = handle_message(msg, db)
+    assert response["new_stored"] == 0
+    assert response["duplicates"] == 1
+
+
+def test_handle_sync_filters_short(tmp_path: Path) -> None:
+    """Short/noise prompts should be filtered out."""
+    db = PromptDB(tmp_path / "test.db")
+    msg = {
+        "type": "sync_prompts",
+        "prompts": [
+            {
+                "text": "ok",
+                "source": "chatgpt-ext",
+                "timestamp": "",
+                "conversation_id": "c1",
+                "conversation_title": "t",
+            },
+            {
+                "text": "yes",
+                "source": "chatgpt-ext",
+                "timestamp": "",
+                "conversation_id": "c1",
+                "conversation_title": "t",
+            },
+        ],
+    }
+    response = handle_message(msg, db)
+    assert response["received"] == 2
+    assert response["new_stored"] == 0
+
+
+def test_handle_get_status(tmp_path: Path) -> None:
+    db = PromptDB(tmp_path / "test.db")
+    # Insert a prompt so stats are non-empty
+    db.insert_prompt(
+        "Test prompt for status check", source="chatgpt-ext", project="test", session_id="s1"
+    )
+    response = handle_message({"type": "get_status"}, db)
+    assert response["type"] == "status"
+    assert response["total_prompts"] >= 1
+    assert "version" in response
+
+
+def test_handle_unknown_type(tmp_path: Path) -> None:
+    db = PromptDB(tmp_path / "test.db")
+    response = handle_message({"type": "unknown_xyz"}, db)
+    assert response["type"] == "error"
+    assert "unknown" in response["message"].lower()
+
+
+def test_handle_empty_sync(tmp_path: Path) -> None:
+    db = PromptDB(tmp_path / "test.db")
+    response = handle_message({"type": "sync_prompts", "prompts": []}, db)
+    assert response["type"] == "sync_result"
+    assert response["received"] == 0
+    assert response["new_stored"] == 0
+
+
+# -- Insights in sync response --
+
+
+def test_sync_result_includes_insights(tmp_path: Path) -> None:
+    """sync_result should always include an insights dict."""
+    db = PromptDB(tmp_path / "test.db")
+    msg = {
+        "type": "sync_prompts",
+        "prompts": [
+            {
+                "text": "Explain the difference between threads and processes in Python",
+                "source": "chatgpt-ext",
+                "timestamp": "2026-03-20T10:00:00Z",
+                "conversation_id": "c1",
+                "conversation_title": "",
+            },
+        ],
+    }
+    response = handle_message(msg, db)
+    assert "insights" in response
+    insights = response["insights"]
+    assert "avg_score" in insights
+    assert "total_prompts" in insights
+    assert "score_trend" in insights
+    assert insights["score_trend"] in ("improving", "declining", "stable")
+
+
+def test_sync_insights_empty_db(tmp_path: Path) -> None:
+    """Empty DB sync should return zero insights with stable trend."""
+    db = PromptDB(tmp_path / "test.db")
+    response = handle_message({"type": "sync_prompts", "prompts": []}, db)
+    insights = response["insights"]
+    assert insights["avg_score"] == 0.0
+    assert insights["total_prompts"] == 0
+    assert insights["score_trend"] == "stable"
+    assert insights["top_insight"] is None
+
+
+def test_sync_insights_with_scored_prompts(tmp_path: Path) -> None:
+    """Insights should reflect stored scores when features exist."""
+    db = PromptDB(tmp_path / "test.db")
+    # Insert prompts and store features to simulate scored data
+    for i in range(10):
+        text = f"Implement a Python decorator that caches function results variant {i}"
+        db.insert_prompt(text, source="chatgpt-ext", project="test", session_id="s1")
+        import hashlib
+
+        h = hashlib.sha256(text.encode()).hexdigest()
+        db.store_features(h, {"overall_score": 60.0 + i, "task_type": "implement"})
+
+    response = handle_message({"type": "sync_prompts", "prompts": []}, db)
+    insights = response["insights"]
+    assert insights["total_prompts"] == 10
+    assert insights["avg_score"] > 0
+
+
+def test_sync_insights_trend_improving(tmp_path: Path) -> None:
+    """Score trend should detect improvement."""
+    db = PromptDB(tmp_path / "test.db")
+    import hashlib
+
+    # Insert 30 prompts: older ones low score, recent ones high score
+    for i in range(30):
+        ts = f"2026-03-{10 + i // 2:02d}T{10 + i % 24:02d}:00:00Z"
+        text = f"Write a comprehensive test suite for the user auth module version {i}"
+        db.insert_prompt(text, source="chatgpt-ext", project="test", session_id="s1", timestamp=ts)
+        h = hashlib.sha256(text.encode()).hexdigest()
+        # Older prompts (higher i = more recent timestamp) get higher scores
+        score = 40.0 + i * 1.5
+        db.store_features(h, {"overall_score": score, "task_type": "test"})
+
+    response = handle_message({"type": "sync_prompts", "prompts": []}, db)
+    insights = response["insights"]
+    assert insights["score_trend"] == "improving"
+
+
+def test_sync_insights_trend_declining(tmp_path: Path) -> None:
+    """Score trend should detect decline."""
+    db = PromptDB(tmp_path / "test.db")
+    import hashlib
+
+    for i in range(30):
+        ts = f"2026-03-{10 + i // 2:02d}T{10 + i % 24:02d}:00:00Z"
+        text = f"Debug the authentication middleware crash in production variant {i}"
+        db.insert_prompt(text, source="chatgpt-ext", project="test", session_id="s1", timestamp=ts)
+        h = hashlib.sha256(text.encode()).hexdigest()
+        # More recent = lower score
+        score = 85.0 - i * 1.5
+        db.store_features(h, {"overall_score": score, "task_type": "debug"})
+
+    response = handle_message({"type": "sync_prompts", "prompts": []}, db)
+    insights = response["insights"]
+    assert insights["score_trend"] == "declining"
+
+
+# -- get_insights message type --
+
+
+def test_handle_get_insights_empty(tmp_path: Path) -> None:
+    """get_insights on empty DB should return valid structure."""
+    db = PromptDB(tmp_path / "test.db")
+    response = handle_message({"type": "get_insights"}, db)
+    assert response["type"] == "insights_result"
+    assert response["avg_score"] == 0.0
+    assert response["prompt_count"] == 0
+    assert response["insights"] == []
+
+
+def test_handle_get_insights_with_data(tmp_path: Path) -> None:
+    """get_insights should return analysis when data exists."""
+    db = PromptDB(tmp_path / "test.db")
+    import hashlib
+
+    for i in range(10):
+        text = f"Refactor the database connection pool to use async context managers v{i}"
+        db.insert_prompt(
+            text,
+            source="claude-ext",
+            project="test",
+            session_id="s1",
+            timestamp=f"2026-03-{15 + i}T10:00:00Z",
+        )
+        h = hashlib.sha256(text.encode()).hexdigest()
+        db.store_features(
+            h,
+            {
+                "overall_score": 55.0 + i,
+                "task_type": "refactor",
+                "key_instruction_position": 0.1,
+                "keyword_repetition_freq": 0.2,
+                "context_specificity": 0.4,
+                "has_constraints": False,
+                "ambiguity_score": 0.3,
+                "compressibility": 0.2,
+                "source": "claude-ext",
+                "token_count": 50,
+            },
+        )
+
+    response = handle_message({"type": "get_insights"}, db)
+    assert response["type"] == "insights_result"
+    assert response["prompt_count"] == 10
+    assert response["avg_score"] > 0
+
+
+def test_handle_get_insights_with_source_filter(tmp_path: Path) -> None:
+    """get_insights should respect source filter."""
+    db = PromptDB(tmp_path / "test.db")
+    import hashlib
+
+    # ChatGPT prompts
+    for i in range(5):
+        text = f"Explain Python decorators with practical examples variant {i}"
+        db.insert_prompt(text, source="chatgpt-ext", project="t", session_id="s1")
+        h = hashlib.sha256(text.encode()).hexdigest()
+        db.store_features(
+            h,
+            {
+                "overall_score": 70.0,
+                "task_type": "explain",
+                "source": "chatgpt-ext",
+                "token_count": 30,
+            },
+        )
+
+    # Claude prompts
+    for i in range(5):
+        text = f"Create a REST API with FastAPI for user management variant {i}"
+        db.insert_prompt(text, source="claude-ext", project="t", session_id="s2")
+        h = hashlib.sha256(text.encode()).hexdigest()
+        db.store_features(
+            h,
+            {
+                "overall_score": 80.0,
+                "task_type": "implement",
+                "source": "claude-ext",
+                "token_count": 40,
+            },
+        )
+
+    # Filter to chatgpt only
+    response = handle_message({"type": "get_insights", "source": "chatgpt-ext"}, db)
+    assert response["type"] == "insights_result"
+    assert response["prompt_count"] == 5
+
+
+# -- DB: get_recent_scores --
+
+
+def test_get_recent_scores_empty(tmp_path: Path) -> None:
+    db = PromptDB(tmp_path / "test.db")
+    assert db.get_recent_scores() == []
+
+
+def test_get_recent_scores_ordered(tmp_path: Path) -> None:
+    """Scores should be returned newest-first."""
+    db = PromptDB(tmp_path / "test.db")
+    import hashlib
+
+    texts = [
+        ("Oldest prompt about Python typing", "2026-03-01T10:00:00Z", 50.0),
+        ("Middle prompt about async patterns", "2026-03-15T10:00:00Z", 70.0),
+        ("Newest prompt about testing strategies", "2026-03-30T10:00:00Z", 90.0),
+    ]
+    for text, ts, score in texts:
+        db.insert_prompt(text, source="test", project="p", session_id="s", timestamp=ts)
+        h = hashlib.sha256(text.encode()).hexdigest()
+        db.store_features(h, {"overall_score": score, "task_type": "other"})
+
+    scores = db.get_recent_scores(limit=10)
+    assert len(scores) == 3
+    # Newest first
+    assert scores[0] == 90.0
+    assert scores[-1] == 50.0
+
+
+def test_get_recent_scores_respects_limit(tmp_path: Path) -> None:
+    db = PromptDB(tmp_path / "test.db")
+    import hashlib
+
+    for i in range(20):
+        text = f"Generate unit tests for the payment processing module variant {i}"
+        db.insert_prompt(
+            text,
+            source="test",
+            project="p",
+            session_id="s",
+            timestamp=f"2026-03-{i + 1:02d}T10:00:00Z",
+        )
+        h = hashlib.sha256(text.encode()).hexdigest()
+        db.store_features(h, {"overall_score": 50.0 + i, "task_type": "test"})
+
+    scores = db.get_recent_scores(limit=5)
+    assert len(scores) == 5