reprompt-cli 1.4.0__tar.gz → 1.4.1__tar.gz

{reprompt_cli-1.4.0 → reprompt_cli-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reprompt-cli
-Version: 1.4.0
+Version: 1.4.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.4.0 → reprompt_cli-1.4.1}/docs/roadmap.md

@@ -1,6 +1,6 @@
 # reprompt Roadmap
 
-> Last updated: 2026-03-24 · Current version: v1.4.0
+> Last updated: 2026-03-25 · Current version: v1.4.1
 
 ## Vision
 
@@ -35,9 +35,10 @@ Claude Code · OpenClaw · Cursor IDE · Aider · Gemini CLI · Cline · ChatGPT
 | v1.3.0 | Conversation distillation | `reprompt distill` — 6-signal importance scoring for conversation turns |
 | v1.3.1 | UX polish | Actionable suggestions on 5 commands, `--source` filter on all data commands |
 | v1.4.0 | Context recovery + consolidation | `distill --export` context document, signal transparency, command consolidation (27→23) |
+| v1.4.1 | Compare + style polish | `compare --best-worst` auto-pick, `style --trends` period-over-period deltas |
 
 ### Quality
-- 1295 tests, ≥90% coverage
+- 1316 tests, ≥90% coverage
 - Strict mypy, ruff lint/format
 - CI: coverage gate + pre-publish test step
 - Stable public API (`score_prompt`, `compare_prompts`, `extract_features`)
@@ -51,12 +52,12 @@ Claude Code · OpenClaw · Cursor IDE · Aider · Gemini CLI · Cline · ChatGPT
 | P1 | `distill --export` context recovery | **DONE** — community signal: resume sessions after compaction/timeout |
 | P2 | Command consolidation: `save`/`templates`/`use` → `template [save\|list\|use]` | **DONE** — 3 commands doing 1 thing = cognitive overload |
 | P2 | Command consolidation: `effectiveness`/`merge-view` → `insights` sub-insights | **DONE** — concepts unclear to users |
-| P3 | `style` shows change trends | "specificity +12% this week" drives revisits |
+| P3 | `style` shows change trends | **DONE** — `--trends` flag with period-over-period deltas |
 | P4 | `distill --show-weights` / `--weights` signal transparency | Community request for weight visibility |
-| P5 | `compare --best-worst` auto-pick | Auto-pick best/worst from DB |
-| P5 | `--copy` as standard option on remaining commands | Consistency |
+| P5 | `compare --best-worst` auto-pick | **DONE** — auto-selects from DB scores |
+| P5 | `--copy` as standard option on remaining commands | Decided against — no clear paste destination for analysis commands |
 
-**Status: 27 → 23 visible commands. P1+P2 shipped. Context recovery + consolidation done.**
+**Status: 27 → 23 visible commands. P1+P2+P3+P5 shipped.**
 
 ---
 
@@ -64,6 +65,7 @@ Claude Code · OpenClaw · Cursor IDE · Aider · Gemini CLI · Cline · ChatGPT
 
 | Feature | Description |
 |---------|-------------|
+| Distill false positive reduction | Position signal breaks on small-talk openers / "thanks bye" closers; long error dumps score high on length+uniqueness but aren't decision points; "ok try again" triggers error_recovery but is noise. Community feedback from r/LLMDevs. |
 | Sensitive content detection | Privacy narrative; PII in prompts |
 | Agent workflow analysis | Multi-step agent session patterns |
 | `.reprompt.yml` configurable lint | Team/Pro direction |

reprompt_cli-1.4.1/docs/superpowers/specs/2026-03-24-v141-polish-design.md

@@ -0,0 +1,184 @@
+# v1.4.1 Polish Design Spec
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development or superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Two UX improvements that make existing commands more useful without adding new commands.
+
+**Version:** v1.4.1 (patch release)
+
+---
+
+## Feature 1: `compare --best-worst`
+
+### Problem
+
+`reprompt compare` requires users to manually type two prompt strings. Most users want a quick "show me my best vs worst" without digging through the database.
+
+### Solution
+
+Add `--best-worst` flag that auto-selects the highest-scored and lowest-scored prompts from `prompt_features`, then runs the existing comparison logic.
+
+### Interface
+
+```bash
+# Existing (unchanged)
+reprompt compare "prompt A" "prompt B"
+
+# New
+reprompt compare --best-worst
+reprompt compare --best-worst --json
+reprompt compare --best-worst --source claude-code
+```
+
+### Implementation Details
+
+**CLI changes (`cli.py`):**
+- `prompt_a` and `prompt_b` become `Optional[str]` (default `None`)
+- Add `--best-worst` flag (bool, default `False`)
+- Add `--source` filter (str, optional) for consistency
+- Manual mutual-exclusion guard at top of function body (Typer has no built-in mechanism):
+  ```python
+  if best_worst and (prompt_a or prompt_b):
+      console.print("[red]--best-worst cannot be combined with prompt arguments[/red]")
+      raise typer.Exit(1)
+  if not best_worst and not (prompt_a and prompt_b):
+      console.print("[red]Provide two prompts or use --best-worst[/red]")
+      raise typer.Exit(1)
+  ```
+  Pattern matches existing `distill` command (cli.py:963–971).
+- When `--best-worst`: call `db.get_best_worst_prompts(source)` to get texts, then run existing scoring logic
+
+**DB method (`storage/db.py`):**
+```python
+def get_best_worst_prompts(self, source: str | None = None) -> tuple[str, str] | None:
+    """Return (best_text, worst_text) from scored prompts.
+
+    Filters to prompts with word_count >= 5 to avoid noise.
+    Returns None if fewer than 2 qualifying prompts exist.
+    """
+```
+
+Query: JOIN `prompt_features` ON `prompts.hash = prompt_features.prompt_hash`, filter `overall_score IS NOT NULL`, order by score DESC for best and ASC for worst. Filter in Python after the JOIN: fetch all scored rows with their `prompts.text`, apply `len(text.split()) >= 5`, then take max/min `overall_score` rows from survivors. This avoids JSON parsing in the hot path and is straightforward to test.
+
+**Terminal output enhancement:**
+When using `--best-worst`, show the prompt texts (truncated to 80 chars) above the comparison table so the user knows what's being compared.
+
+### Edge Cases
+
+- Fewer than 2 scored prompts: print guidance ("Run `reprompt scan` then `reprompt score` to build your score history")
+- Best and worst are the same prompt (only 1 unique score): print message ("All prompts have similar scores")
+- `--best-worst` combined with positional args: error with clear message
+
+---
+
+## Feature 2: `style --trends`
+
+### Problem
+
+`reprompt style` shows a static snapshot. Users have no way to see if their prompting style is improving over time.
+
+### Solution
+
+Add `--trends` flag that compares current period vs previous period style metrics, showing deltas.
+
+### Interface
+
+```bash
+# Existing (unchanged)
+reprompt style
+reprompt style --json
+
+# New
+reprompt style --trends
+reprompt style --trends --period 30d
+reprompt style --trends --json
+reprompt style --trends --source claude-code
+```
+
+### Implementation Details
+
+**New function in `core/style.py`:**
+```python
+def compute_style_trends(
+    db: PromptDB,
+    period: str = "7d",
+    source: str | None = None,
+) -> dict[str, Any]:
+    """Compare style between current and previous period.
+
+    Returns dict with:
+      period, current (style dict), previous (style dict),
+      deltas: {specificity, avg_length, top_category_changed, prompt_count}
+    """
+```
+
+Reuses:
+- `sliding_windows(period, count=2)` from `core/timeutil` — returns `list[TimeWindow]` with `.start`/`.end` as `datetime` objects
+- `db.get_prompts_in_range(start, end, source=source)` — `source` is keyword-only; `start`/`end` must be ISO-8601 strings, so call `window.start.isoformat()` / `window.end.isoformat()` before passing
+- `compute_style(prompts)` applied to each window's prompts
+- `categorize_prompt()` from `core/library` to build prompt dicts
+
+**Delta computation:**
+- `specificity_delta`: current - previous (e.g., +0.12)
+- `avg_length_delta`: current - previous (e.g., +15.3 chars)
+- `prompt_count_delta`: current - previous
+- `top_category_changed`: bool (did the top category shift?)
+- `top_category_current` / `top_category_previous`: for display
+
+**CLI changes (`cli.py`):**
+- Add `--trends` flag (bool, default `False`)
+- Add `--period` option (str, default `"7d"`)
+- When `--trends`: call `compute_style_trends()`, render with new function
+
+**Terminal rendering (`output/terminal.py`):**
+New `render_style_trends(data)` function. Output format:
+
+```
+  Style Trends (7d)
+  ─────────────────────────────────
+  Specificity   0.72 → 0.84  (+12%)
+  Avg Length     45 → 52 chars (+16%)
+  Prompts        23 → 31  (+35%)
+  Top Category   debugging → refactoring
+```
+
+Coloring rules:
+- `Specificity`: green if positive delta (higher = better), red if negative
+- `Prompts`: green if positive delta (more activity = good), dim if negative
+- `Avg Length`: always `[dim]` (neutral metric, no green/red — length is not inherently better or worse)
+- `Top Category`: no color, just show the shift
+
+**JSON output:** Return raw `{period, current, previous, deltas}` dict.
+
+### Edge Cases
+
+- No prompts in either window: "Not enough data for trends. Keep prompting and check back next week."
+- No prompts in previous window only: show current stats with "New! No previous data to compare."
+- `--trends` combined with existing `--json`: works (returns trends JSON instead of snapshot JSON)
+
+---
+
+## What's NOT in v1.4.1
+
+- `--copy` standardization: decided against (no clear paste destination for analysis commands)
+- New commands: none
+- Breaking changes: none
+
+## Testing
+
+- `compare --best-worst`: ~8 tests (DB method, CLI integration, edge cases, JSON output, source filter, mutual exclusion with args)
+- `style --trends`: ~8 tests (compute function, CLI integration, edge cases, JSON output, source filter, period option)
+- Total estimated: ~16 new tests
+
+## Files Modified
+
+| File | Change |
+|------|--------|
+| `src/reprompt/cli.py` | `compare` gains `--best-worst`/`--source`; `style` gains `--trends`/`--period` |
+| `src/reprompt/storage/db.py` | Add `get_best_worst_prompts()` |
+| `src/reprompt/core/style.py` | Add `compute_style_trends()` |
+| `src/reprompt/output/terminal.py` | Add `render_style_trends()`, modify `render_compare()` for prompt text display |
+| `pyproject.toml` | Version bump to 1.4.1 |
+| `src/reprompt/__init__.py` | Version bump to 1.4.1 |
+| `tests/test_compare_best_worst.py` | New test file |
+| `tests/test_style_trends.py` | New test file |

{reprompt_cli-1.4.0 → reprompt_cli-1.4.1}/pyproject.toml

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

{reprompt_cli-1.4.0 → reprompt_cli-1.4.1}/src/reprompt/__init__.py

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

{reprompt_cli-1.4.0 → reprompt_cli-1.4.1}/src/reprompt/cli.py

@@ -709,18 +709,34 @@ def style(
     source: str | None = typer.Option(
         None, "--source", "-s", help="Filter by source (e.g. claude-code, cursor, aider)"
     ),
+    trends: bool = typer.Option(False, "--trends", help="Show style change trends"),
+    period: str = typer.Option("7d", "--period", help="Comparison period (with --trends)"),
 ) -> None:
     """Show your personal prompting style fingerprint."""
     import json as json_mod
 
     from reprompt.config import Settings
-    from reprompt.core.library import categorize_prompt
-    from reprompt.core.style import compute_style
-    from reprompt.output.terminal import render_style
     from reprompt.storage.db import PromptDB
 
     settings = Settings()
     db = PromptDB(settings.db_path)
+
+    if trends:
+        from reprompt.core.style import compute_style_trends
+        from reprompt.output.terminal import render_style_trends
+
+        data = compute_style_trends(db, period=period, source=source)
+
+        if json_output:
+            print(json_mod.dumps(data, indent=2))
+        else:
+            print(render_style_trends(data), end="")
+        return
+
+    from reprompt.core.library import categorize_prompt
+    from reprompt.core.style import compute_style
+    from reprompt.output.terminal import render_style
+
     rows = db.get_all_prompts(source=source)
     prompts = [
         {
@@ -1231,15 +1247,55 @@ def _load_conversation(
 
 @app.command()
 def compare(
-    prompt_a: str = typer.Argument(..., help="First prompt"),
-    prompt_b: str = typer.Argument(..., help="Second prompt"),
+    prompt_a: str | None = typer.Argument(None, help="First prompt"),
+    prompt_b: str | None = typer.Argument(None, help="Second prompt"),
     json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    best_worst: bool = typer.Option(
+        False, "--best-worst", help="Auto-select best and worst from DB"
+    ),
+    source: str | None = typer.Option(
+        None, "--source", "-s", help="Filter by source (with --best-worst)"
+    ),
 ) -> None:
     """Compare two prompts side by side using Prompt DNA analysis."""
+    from typing import Any
+
     from reprompt.core.extractors import extract_features
     from reprompt.core.prompt_dna import PromptDNA
     from reprompt.core.scorer import ScoreBreakdown, score_prompt
 
+    # Mutual exclusion guard
+    if best_worst and (prompt_a or prompt_b):
+        console.print("[red]--best-worst cannot be combined with prompt arguments[/red]")
+        raise typer.Exit(1)
+    if not best_worst and not (prompt_a and prompt_b):
+        console.print("[red]Provide two prompts or use --best-worst[/red]")
+        raise typer.Exit(1)
+
+    prompt_a_text: str | None = None
+    prompt_b_text: str | None = None
+
+    if best_worst:
+        from reprompt.config import Settings
+        from reprompt.storage.db import PromptDB
+
+        settings = Settings()
+        db = PromptDB(settings.db_path)
+        pair = db.get_best_worst_prompts(source=source)
+        if pair is None:
+            console.print(
+                "Not enough scored prompts. Run [bold]reprompt scan[/bold]"
+                " to build your score history."
+            )
+            raise typer.Exit(1)
+        prompt_a = pair[0]  # best
+        prompt_b = pair[1]  # worst
+        prompt_a_text = prompt_a
+        prompt_b_text = prompt_b
+
+    # Type narrowing for mypy strict (guards above guarantee non-None)
+    assert prompt_a is not None and prompt_b is not None
+
     dna_a = extract_features(prompt_a, source="manual", session_id="compare-a")
     dna_b = extract_features(prompt_b, source="manual", session_id="compare-b")
     score_a = score_prompt(dna_a)
@@ -1259,11 +1315,16 @@ def compare(
             "ambiguity_score": dna.ambiguity_score,
         }
 
-    result = {
+    result: dict[str, Any] = {
         "prompt_a": _build_data(dna_a, score_a),
         "prompt_b": _build_data(dna_b, score_b),
     }
 
+    # Include prompt texts for --best-worst display
+    if prompt_a_text:
+        result["prompt_a_text"] = prompt_a_text
+        result["prompt_b_text"] = prompt_b_text
+
     if json_output:
         import json as json_mod
 

{reprompt_cli-1.4.0 → reprompt_cli-1.4.1}/src/reprompt/core/style.py

@@ -13,7 +13,10 @@ from __future__ import annotations
 
 import re
 from collections import Counter
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from reprompt.storage.db import PromptDB
 
 # Patterns that indicate specificity
 _FILE_REF = re.compile(r"[\w/]+\.\w{1,5}")  # file.py, path/to/file.ts
@@ -105,3 +108,61 @@ def compute_style(prompts: list[dict[str, Any]]) -> dict[str, Any]:
         "specificity": round(specificity, 2),
         "length_distribution": length_dist,
     }
+
+
+def compute_style_trends(
+    db: PromptDB,
+    period: str = "7d",
+    source: str | None = None,
+) -> dict[str, Any]:
+    """Compare style between current and previous period.
+
+    Returns dict with:
+      period, current (style dict), previous (style dict),
+      deltas: {specificity, avg_length, prompt_count,
+               top_category_changed, top_category_current, top_category_previous}
+    """
+    from reprompt.core.library import categorize_prompt
+    from reprompt.core.timeutil import sliding_windows
+
+    windows = sliding_windows(period=period, count=2)
+    prev_window = windows[0]
+    curr_window = windows[1]
+
+    def _build_prompts(window):
+        rows = db.get_prompts_in_range(
+            window.start.isoformat(),
+            window.end.isoformat(),
+            source=source,
+        )
+        return [
+            {
+                "text": r["text"],
+                "category": categorize_prompt(r["text"]),
+                "char_count": r.get("char_count", len(r["text"])),
+            }
+            for r in rows
+            if r.get("duplicate_of") is None
+        ]
+
+    prev_prompts = _build_prompts(prev_window)
+    curr_prompts = _build_prompts(curr_window)
+
+    previous = compute_style(prev_prompts)
+    current = compute_style(curr_prompts)
+
+    deltas: dict[str, Any] = {
+        "specificity": round(current["specificity"] - previous["specificity"], 2),
+        "avg_length": round(current["avg_length"] - previous["avg_length"], 1),
+        "prompt_count": current["prompt_count"] - previous["prompt_count"],
+        "top_category_changed": current["top_category"] != previous["top_category"],
+        "top_category_current": current["top_category"],
+        "top_category_previous": previous["top_category"],
+    }
+
+    return {
+        "period": period,
+        "current": current,
+        "previous": previous,
+        "deltas": deltas,
+    }

{reprompt_cli-1.4.0 → reprompt_cli-1.4.1}/src/reprompt/output/terminal.py

@@ -462,6 +462,18 @@ def render_compare(data: dict[str, Any]) -> str:
 
     console.print("\n[bold]Prompt Comparison[/bold]")
 
+    # Show prompt texts if provided (from --best-worst)
+    if "prompt_a_text" in data:
+        a_text = data["prompt_a_text"]
+        b_text = data["prompt_b_text"]
+
+        def _truncate(t: str) -> str:
+            return (t[:77] + "...") if len(t) > 80 else t
+
+        console.print(f"  [green]Best:[/green]  {_truncate(a_text)}")
+        console.print(f"  [red]Worst:[/red] {_truncate(b_text)}")
+        console.print()
+
     table = Table()
     table.add_column("Feature", style="dim", min_width=18)
     table.add_column("Prompt A", justify="right")
@@ -657,6 +669,84 @@ def render_style(data: dict[str, Any]) -> str:
     return buf.getvalue()
 
 
+def render_style_trends(data: dict[str, Any]) -> str:
+    """Render style trends comparison between two periods."""
+    buf = StringIO()
+    console = Console(file=buf, force_terminal=True, width=80)
+
+    curr = data["current"]
+    prev = data["previous"]
+    deltas = data["deltas"]
+
+    # Handle empty data
+    if curr["prompt_count"] == 0 and prev["prompt_count"] == 0:
+        console.print(
+            "\n[dim]Not enough data for trends. Keep prompting and check back next week.[/dim]"
+        )
+        return buf.getvalue()
+
+    if prev["prompt_count"] == 0:
+        console.print(f"\n[bold]Style Trends ({data['period']})[/bold]")
+        console.print("\u2500" * 40)
+        console.print("  [dim]New! No previous data to compare.[/dim]")
+        console.print(
+            f"  Current: {curr['prompt_count']} prompts,"
+            f" specificity {curr['specificity']:.2f},"
+            f" avg {curr['avg_length']:.0f} chars"
+        )
+        return buf.getvalue()
+
+    console.print(f"\n[bold]Style Trends ({data['period']})[/bold]")
+    console.print("\u2500" * 40)
+
+    # Specificity (green = improvement)
+    spec_delta = deltas["specificity"]
+    spec_sign = "+" if spec_delta > 0 else ""
+    spec_pct = (
+        f" ({spec_sign}{spec_delta / prev['specificity'] * 100:.0f}%)"
+        if prev["specificity"] > 0
+        else ""
+    )
+    spec_color = "green" if spec_delta > 0 else "red" if spec_delta < 0 else "dim"
+    console.print(
+        f"  Specificity   {prev['specificity']:.2f}"
+        f" \u2192 {curr['specificity']:.2f}"
+        f"  [{spec_color}]{spec_sign}{spec_delta:.2f}"
+        f"{spec_pct}[/{spec_color}]"
+    )
+
+    # Avg Length (neutral, always dim)
+    len_delta = deltas["avg_length"]
+    len_sign = "+" if len_delta > 0 else ""
+    console.print(
+        f"  Avg Length    {prev['avg_length']:.0f}"
+        f" \u2192 {curr['avg_length']:.0f} chars"
+        f"  [dim]{len_sign}{len_delta:.0f} chars[/dim]"
+    )
+
+    # Prompt count (green = more activity)
+    count_delta = deltas["prompt_count"]
+    count_sign = "+" if count_delta > 0 else ""
+    count_color = "green" if count_delta > 0 else "dim"
+    console.print(
+        f"  Prompts       {prev['prompt_count']}"
+        f" \u2192 {curr['prompt_count']}"
+        f"  [{count_color}]{count_sign}{count_delta}[/{count_color}]"
+    )
+
+    # Top category shift
+    if deltas["top_category_changed"]:
+        console.print(
+            f"  Top Category  {deltas['top_category_previous']}"
+            f" \u2192 {deltas['top_category_current']}"
+        )
+    else:
+        console.print(f"  Top Category  {deltas['top_category_current']} (unchanged)")
+
+    console.print()
+    return buf.getvalue()
+
+
 def render_privacy(data: dict[str, Any]) -> str:
     """Render privacy exposure summary."""
     buf = StringIO()

{reprompt_cli-1.4.0 → reprompt_cli-1.4.1}/src/reprompt/storage/db.py

@@ -954,6 +954,46 @@ class PromptDB:
         finally:
             conn.close()
 
+    def get_best_worst_prompts(self, source: str | None = None) -> tuple[str, str] | None:
+        """Return (best_text, worst_text) from scored prompts.
+
+        Filters to prompts with >= 5 words to avoid noise.
+        Returns None if fewer than 2 qualifying prompts exist.
+        """
+        conn = self._conn()
+        try:
+            if source:
+                rows = conn.execute(
+                    """SELECT p.text, pf.overall_score
+                       FROM prompt_features pf
+                       JOIN prompts p ON pf.prompt_hash = p.hash
+                       WHERE pf.overall_score IS NOT NULL AND p.source = ?
+                       ORDER BY pf.overall_score DESC""",
+                    (source,),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    """SELECT p.text, 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 pf.overall_score DESC""",
+                ).fetchall()
+
+            # Filter to prompts with >= 5 words
+            qualified = [
+                (row["text"], row["overall_score"]) for row in rows if len(row["text"].split()) >= 5
+            ]
+
+            if len(qualified) < 2:
+                return None
+
+            best_text = qualified[0][0]  # highest score (first in DESC order)
+            worst_text = qualified[-1][0]  # lowest score (last in DESC order)
+            return (best_text, worst_text)
+        finally:
+            conn.close()
+
     # -- digest_log ---------------------------------------------------------
 
     def log_digest(