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

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

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

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

reprompt_cli-1.9.1/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.1}/src/reprompt/cli.py

@@ -820,13 +820,19 @@ def lint(
     import json as json_mod
 
     from reprompt.config import Settings
-    from reprompt.core.lint import format_lint_results, lint_prompts
+    from reprompt.core.lint import format_lint_results, lint_prompts, load_lint_config
     from reprompt.core.pipeline import get_adapters
     from reprompt.storage.db import PromptDB
 
     settings = Settings()
     db = PromptDB(settings.db_path)
 
+    # Load lint config from .reprompt.toml / pyproject.toml
+    lint_config = load_lint_config()
+
+    # CLI flags override config file
+    effective_threshold = score_threshold if score_threshold > 0 else lint_config.score_threshold
+
     # Collect prompts from DB (already scanned)
     rows = db.get_all_prompts()
     texts = [r["text"] for r in rows]
@@ -858,11 +864,11 @@ def lint(
         console.print("No prompts found. Run [bold]reprompt scan[/bold] first.")
         raise typer.Exit(0)
 
-    violations = lint_prompts(texts)
+    violations = lint_prompts(texts, config=lint_config)
 
     # Score threshold mode (CI integration)
     score_data = None
-    if score_threshold > 0:
+    if effective_threshold > 0:
         from reprompt.core.extractors import extract_features
         from reprompt.core.scorer import score_prompt
 
@@ -875,8 +881,8 @@ def lint(
             "avg_score": round(avg_score, 1),
             "min_score": min(scores) if scores else 0,
             "max_score": max(scores) if scores else 0,
-            "threshold": score_threshold,
-            "pass": avg_score >= score_threshold,
+            "threshold": effective_threshold,
+            "pass": avg_score >= effective_threshold,
         }
 
     if json_output:
@@ -905,7 +911,7 @@ def lint(
             console.print(
                 f"\n  Score: avg {score_data['avg_score']}/100"
                 f" (min {score_data['min_score']}, max {score_data['max_score']})"
-                f" — threshold {score_threshold} → {status}"
+                f" — threshold {effective_threshold} → {status}"
             )
 
     if copy:

reprompt_cli-1.9.1/src/reprompt/core/lint.py

@@ -0,0 +1,242 @@
+"""Prompt quality linting rules.
+
+Checks prompts against configurable quality rules and returns violations.
+Designed for CI integration — each rule produces a severity + message.
+
+Configuration loaded from (highest priority wins):
+1. CLI flags (--score-threshold, --strict)
+2. .reprompt.toml in CWD or parents
+3. [tool.reprompt.lint] in pyproject.toml
+4. Built-in defaults
+"""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomllib
+    except ModuleNotFoundError:  # Python 3.10
+        import tomli as tomllib  # type: ignore[no-redefine]
+
+
+@dataclass
+class LintViolation:
+    """A single lint rule violation."""
+
+    rule: str
+    severity: str  # "error" | "warning"
+    message: str
+    prompt_text: str
+
+
+@dataclass
+class LintConfig:
+    """Configuration for lint rules. Loaded from .reprompt.toml or pyproject.toml."""
+
+    # Rule thresholds (0 = disabled)
+    min_length: int = 20
+    short_prompt: int = 40
+
+    # Boolean rules (False = disabled)
+    vague_prompt: bool = True
+    debug_needs_reference: bool = True
+
+    # File extensions for debug-needs-reference
+    file_extensions: list[str] = field(
+        default_factory=lambda: [".py", ".ts", ".js", ".go", ".rs", ".java", ".rb", ".cpp", ".c"]
+    )
+
+    # CI score threshold (0 = disabled, set via --score-threshold or config)
+    score_threshold: int = 0
+
+
+# --- Default config ---
+DEFAULT_CONFIG = LintConfig()
+
+VAGUE_STARTERS = frozenset(
+    {"fix it", "fix this", "do it", "help me", "change it", "update it", "make it work"}
+)
+
+
+def load_lint_config(start_dir: Path | None = None) -> LintConfig:
+    """Load lint config from .reprompt.toml or pyproject.toml, walking up from start_dir.
+
+    Returns DEFAULT_CONFIG if no config file found.
+    """
+    if start_dir is None:
+        start_dir = Path.cwd()
+
+    # Walk up to find config files
+    current = start_dir.resolve()
+    for _ in range(20):  # safety limit
+        # Check .reprompt.toml first (project-specific)
+        reprompt_toml = current / ".reprompt.toml"
+        if reprompt_toml.is_file():
+            return _parse_reprompt_toml(reprompt_toml)
+
+        # Check pyproject.toml
+        pyproject = current / "pyproject.toml"
+        if pyproject.is_file():
+            config = _parse_pyproject_toml(pyproject)
+            if config is not None:
+                return config
+
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+
+    return LintConfig()
+
+
+def _parse_reprompt_toml(path: Path) -> LintConfig:
+    """Parse a .reprompt.toml file."""
+    try:
+        with open(path, "rb") as f:
+            data = tomllib.load(f)
+        return _build_config(data.get("lint", {}))
+    except Exception:
+        return LintConfig()
+
+
+def _parse_pyproject_toml(path: Path) -> LintConfig | None:
+    """Parse [tool.reprompt.lint] from pyproject.toml. Returns None if section missing."""
+    try:
+        with open(path, "rb") as f:
+            data = tomllib.load(f)
+        lint_section = data.get("tool", {}).get("reprompt", {}).get("lint")
+        if lint_section is None:
+            return None
+        return _build_config(lint_section)
+    except Exception:
+        return None
+
+
+def _build_config(lint_data: dict) -> LintConfig:
+    """Build LintConfig from a parsed TOML dict."""
+    config = LintConfig()
+
+    # Top-level lint settings
+    if "score-threshold" in lint_data:
+        config.score_threshold = int(lint_data["score-threshold"])
+
+    # Rule settings
+    rules = lint_data.get("rules", {})
+
+    # min-length: int threshold or false
+    if "min-length" in rules:
+        val = rules["min-length"]
+        config.min_length = int(val) if val else 0
+
+    # short-prompt: int threshold or false
+    if "short-prompt" in rules:
+        val = rules["short-prompt"]
+        config.short_prompt = int(val) if val else 0
+
+    # vague-prompt: bool
+    if "vague-prompt" in rules:
+        config.vague_prompt = bool(rules["vague-prompt"])
+
+    # debug-needs-reference: bool
+    if "debug-needs-reference" in rules:
+        config.debug_needs_reference = bool(rules["debug-needs-reference"])
+
+    # file-extensions: list
+    if "file-extensions" in rules:
+        config.file_extensions = list(rules["file-extensions"])
+
+    return config
+
+
+def lint_prompt(text: str, config: LintConfig | None = None) -> list[LintViolation]:
+    """Lint a single prompt against quality rules."""
+    if config is None:
+        config = DEFAULT_CONFIG
+
+    violations: list[LintViolation] = []
+    stripped = text.strip().lower()
+
+    # Rule 1: Too short
+    if config.min_length > 0 and len(stripped) < config.min_length:
+        violations.append(
+            LintViolation(
+                rule="min-length",
+                severity="error",
+                message=f"Prompt is too short ({len(stripped)} chars, minimum {config.min_length})",
+                prompt_text=text,
+            )
+        )
+    elif config.short_prompt > 0 and len(stripped) < config.short_prompt:
+        violations.append(
+            LintViolation(
+                rule="short-prompt",
+                severity="warning",
+                message=(f"Prompt is short ({len(stripped)} chars) — consider adding context"),
+                prompt_text=text,
+            )
+        )
+
+    # Rule 2: Vague starter
+    if config.vague_prompt and stripped in VAGUE_STARTERS:
+        violations.append(
+            LintViolation(
+                rule="vague-prompt",
+                severity="error",
+                message="Prompt is too vague — specify what to fix/change and where",
+                prompt_text=text,
+            )
+        )
+
+    # Rule 3: No file/function reference in debug prompts
+    if config.debug_needs_reference:
+        debug_words = {"fix", "debug", "bug", "error", "broken", "failing", "crash"}
+        has_debug_intent = any(w in stripped for w in debug_words)
+        indicators = list(config.file_extensions) + ["()", "line ", "file "]
+        has_reference = any(indicator in text for indicator in indicators)
+        min_len = config.min_length if config.min_length > 0 else 20
+        if has_debug_intent and not has_reference and len(stripped) >= min_len:
+            violations.append(
+                LintViolation(
+                    rule="debug-needs-reference",
+                    severity="warning",
+                    message="Debug prompt lacks file/function reference — add specifics",
+                    prompt_text=text,
+                )
+            )
+
+    return violations
+
+
+def lint_prompts(texts: list[str], config: LintConfig | None = None) -> list[LintViolation]:
+    """Lint multiple prompts and return all violations."""
+    violations: list[LintViolation] = []
+    for text in texts:
+        violations.extend(lint_prompt(text, config))
+    return violations
+
+
+def format_lint_results(violations: list[LintViolation], total_prompts: int) -> str:
+    """Format lint results for terminal/CI output."""
+    if not violations:
+        return f"✓ {total_prompts} prompts checked, no issues found"
+
+    errors = [v for v in violations if v.severity == "error"]
+    warnings = [v for v in violations if v.severity == "warning"]
+
+    lines: list[str] = []
+    lines.append(f"Checked {total_prompts} prompts\n")
+
+    for v in violations:
+        prefix = "✗" if v.severity == "error" else "!"
+        display = v.prompt_text[:60] + "..." if len(v.prompt_text) > 60 else v.prompt_text
+        lines.append(f'  {prefix} [{v.rule}] "{display}"')
+        lines.append(f"    {v.message}")
+
+    lines.append(f"\n{len(errors)} error(s), {len(warnings)} warning(s)")
+    return "\n".join(lines)

{reprompt_cli-1.8.1 → reprompt_cli-1.9.1}/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.1}/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"