reprompt-cli 2.0.2__tar.gz → 2.1.0__tar.gz

{reprompt_cli-2.0.2 → reprompt_cli-2.1.0}/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project will be documented in this file.
 
+## [2.1.0] - 2026-04-01
+
+### Added
+- **Model-specific lint rules** — `reprompt lint --model claude/gpt/gemini` checks prompts against model-specific best practices. 8 rules: XML tag preference (Claude), markdown structure (GPT), JSON instruction requirements (GPT), CoT anti-pattern for o-series (GPT), prompt length limits (Gemini), broad negative detection (Gemini). Based on official model documentation.
+- **Diff preview for rewrite** — `reprompt rewrite --diff` shows a git-style unified diff between original and rewritten prompt. Color-coded: red removals, green additions, cyan range markers.
+- **Token budget lint** — `reprompt lint --max-tokens 4096` warns when prompts exceed a token budget. Configurable via `.reprompt.toml` (`max-tokens`) or CLI flag. Uses locale-aware token estimation from cost module.
+- Tests: 1716 → 1741
+
+## [2.0.2] - 2026-04-01
+
+### Changed
+- **Scoring rebalance** — Structure weight reduced 25→15, Clarity increased 15→25. Plain-text prompts now score 55-65 instead of 35-45. Real-world conversational prompts are no longer penalized for lacking markdown structure.
+- **Tier labels** — Scores display as EXPERT (85+), STRONG (70+), GOOD (50+), BASIC (30+), DRAFT (<30) instead of raw numbers. Applied across CLI, extension badge, popup, and HTML dashboard.
+- **Positive UX feedback** — Score output now includes "Strengths" section showing what the prompt does well. Suggestions show expected point gain (`+N pts`). Badge color thresholds adjusted: 85/60/40/25.
+
 ## [2.0.1] - 2026-03-31
 
 ### Added

{reprompt_cli-2.0.2 → reprompt_cli-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reprompt-cli
-Version: 2.0.2
+Version: 2.1.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
@@ -228,7 +228,7 @@ Captured prompts sync locally via Native Messaging -- nothing leaves your machin
 # .pre-commit-config.yaml
 repos:
   - repo: https://github.com/reprompt-dev/reprompt
-    rev: v2.0.1
+    rev: v2.1.0
     hooks:
       - id: reprompt-lint
 ```

{reprompt_cli-2.0.2 → reprompt_cli-2.1.0}/README.md

@@ -183,7 +183,7 @@ Captured prompts sync locally via Native Messaging -- nothing leaves your machin
 # .pre-commit-config.yaml
 repos:
   - repo: https://github.com/reprompt-dev/reprompt
-    rev: v2.0.1
+    rev: v2.1.0
     hooks:
       - id: reprompt-lint
 ```

{reprompt_cli-2.0.2 → reprompt_cli-2.1.0}/pyproject.toml

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

{reprompt_cli-2.0.2 → reprompt_cli-2.1.0}/src/reprompt/cli.py

@@ -797,6 +797,12 @@ def lint(
     score_threshold: int = typer.Option(
         0, "--score-threshold", help="Fail if avg prompt score < threshold (CI mode)"
     ),
+    model: str = typer.Option(
+        None, "--model", "-m", help="Target model for model-specific rules (claude/gpt/gemini)"
+    ),
+    max_tokens: int = typer.Option(
+        0, "--max-tokens", help="Warn when prompts exceed token budget (0 = disabled)"
+    ),
     copy: bool = typer.Option(False, "--copy", help="Copy result to clipboard"),
 ) -> None:
     """Check prompt quality against lint rules.
@@ -806,6 +812,12 @@ def lint(
     - short-prompt: prompts under 40 chars (warning)
     - vague-prompt: overly vague prompts like "fix it"
     - debug-needs-reference: debug prompts without file/function references
+    - max-tokens: prompt exceeds token budget
+
+    Model-specific rules (--model):
+    - claude: suggests XML tags for structure
+    - gpt: warns on XML tags (may echo verbatim), prefers markdown
+    - gemini: warns on very long prompts
 
     CI mode: use --score-threshold to fail if average score is below a threshold.
 
@@ -813,6 +825,8 @@ def lint(
 
         reprompt lint                                    # lint stored prompts
 
+        reprompt lint --model claude                     # with Claude-specific hints
+
         reprompt lint --score-threshold 50               # fail if avg score < 50 (CI mode)
 
         reprompt lint --strict --json                    # strict mode with JSON output
@@ -832,6 +846,10 @@ def lint(
 
     # CLI flags override config file
     effective_threshold = score_threshold if score_threshold > 0 else lint_config.score_threshold
+    if model:
+        lint_config.model = model.lower()
+    if max_tokens > 0:
+        lint_config.max_tokens = max_tokens
 
     # Collect prompts from DB (already scanned)
     rows = db.get_all_prompts()
@@ -1087,6 +1105,7 @@ def compress(
 def rewrite(
     text: str = typer.Argument(..., help="Prompt text to improve"),
     json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    diff: bool = typer.Option(False, "--diff", help="Show unified diff (red/green)"),
     copy: bool = typer.Option(False, "--copy", help="Copy rewritten text to clipboard"),
 ) -> None:
     """Rewrite a prompt to improve its score. Rule-based, no LLM needed.
@@ -1099,9 +1118,9 @@ def rewrite(
 
         reprompt rewrite "I was wondering if you could fix the authentication bug"
 
-        reprompt rewrite "please help me refactor this code to be better" --copy
+        reprompt rewrite "fix the login" --diff
 
-        reprompt rewrite "fix the login" --json
+        reprompt rewrite "please help me refactor this code to be better" --copy
     """
     from reprompt.core.rewrite import rewrite_prompt
 
@@ -1120,6 +1139,10 @@ def rewrite(
             "manual_suggestions": result.manual_suggestions,
         }
         typer.echo(json_mod.dumps(data, indent=2, ensure_ascii=False))
+    elif diff:
+        from reprompt.output.rewrite_terminal import render_rewrite_diff
+
+        typer.echo(render_rewrite_diff(result))
     else:
         from reprompt.output.rewrite_terminal import render_rewrite
 
@@ -2042,6 +2065,13 @@ def init(
 # Useful for CI: reprompt lint --score-threshold reads this value
 # score-threshold = 50
 
+# Target model for model-specific rules (claude, gpt, gemini)
+# Enables rules like "prefer XML tags" (Claude) or "avoid XML tags" (GPT)
+# model = "claude"
+
+# Token budget — warn when prompts exceed this limit (0 = disabled)
+# max-tokens = 4096
+
 [lint.rules]
 # min-length: error if prompt < N chars (0 = disabled)
 min-length = 20

{reprompt_cli-2.0.2 → reprompt_cli-2.1.0}/src/reprompt/core/lint.py

@@ -4,7 +4,7 @@ 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)
+1. CLI flags (--score-threshold, --strict, --model)
 2. .reprompt.toml in CWD or parents
 3. [tool.reprompt.lint] in pyproject.toml
 4. Built-in defaults
@@ -12,6 +12,7 @@ Configuration loaded from (highest priority wins):
 
 from __future__ import annotations
 
+import re
 import sys
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -24,13 +25,16 @@ else:
     except ModuleNotFoundError:  # Python 3.10
         import tomli as tomllib  # type: ignore[no-redefine]
 
+# Valid model targets
+VALID_MODELS = {"claude", "gpt", "gemini"}
+
 
 @dataclass
 class LintViolation:
     """A single lint rule violation."""
 
     rule: str
-    severity: str  # "error" | "warning"
+    severity: str  # "error" | "warning" | "hint"
     message: str
     prompt_text: str
 
@@ -55,6 +59,12 @@ class LintConfig:
     # CI score threshold (0 = disabled, set via --score-threshold or config)
     score_threshold: int = 0
 
+    # Token budget (0 = disabled). Warn when prompt exceeds this many tokens.
+    max_tokens: int = 0
+
+    # Target model for model-specific rules (None = universal rules only)
+    model: str | None = None
+
 
 # --- Default config ---
 DEFAULT_CONFIG = LintConfig()
@@ -126,6 +136,14 @@ def _build_config(lint_data: dict) -> LintConfig:
     if "score-threshold" in lint_data:
         config.score_threshold = int(lint_data["score-threshold"])
 
+    if "max-tokens" in lint_data:
+        config.max_tokens = int(lint_data["max-tokens"])
+
+    if "model" in lint_data:
+        model = str(lint_data["model"]).lower()
+        if model in VALID_MODELS:
+            config.model = model
+
     # Rule settings
     rules = lint_data.get("rules", {})
 
@@ -210,6 +228,150 @@ def lint_prompt(text: str, config: LintConfig | None = None) -> list[LintViolati
                 )
             )
 
+    # Rule 4: Token budget
+    if config.max_tokens > 0:
+        from reprompt.core.cost import estimate_tokens
+
+        tokens = estimate_tokens(text)
+        if tokens > config.max_tokens:
+            violations.append(
+                LintViolation(
+                    rule="max-tokens",
+                    severity="warning",
+                    message=(
+                        f"Prompt is ~{tokens} tokens (budget: {config.max_tokens}) — "
+                        "consider compressing with `reprompt compress`"
+                    ),
+                    prompt_text=text,
+                )
+            )
+
+    # ── Model-specific rules ──
+    if config.model and len(stripped) >= 30:
+        violations.extend(_check_model_rules(text, config.model))
+
+    return violations
+
+
+# ── Model-specific patterns ──
+
+_XML_TAG_RE = re.compile(r"<(?:context|instructions|examples?|constraints?|output|task|role)\b")
+_MD_HEADER_RE = re.compile(r"^#{1,3}\s+\w", re.MULTILINE)
+_JSON_MODE_RE = re.compile(r"(?:respond|output|return|reply|format).*\bjson\b", re.IGNORECASE)
+_COT_RE = re.compile(
+    r"\b(?:think step by step|let'?s think|chain of thought|step-by-step reasoning)\b",
+    re.IGNORECASE,
+)
+_BROAD_NEGATIVE_RE = re.compile(
+    r"\bdo not (?:infer|guess|assume|speculate|make assumptions)\b", re.IGNORECASE
+)
+
+
+def _check_model_rules(text: str, model: str) -> list[LintViolation]:
+    """Return model-specific lint violations and hints."""
+    violations: list[LintViolation] = []
+    has_xml = bool(_XML_TAG_RE.search(text))
+    has_md_headers = bool(_MD_HEADER_RE.search(text))
+    word_count = len(text.split())
+
+    if model == "claude":
+        # Claude: XML tags are preferred for structured prompts
+        if not has_xml and word_count > 50 and not has_md_headers:
+            violations.append(
+                LintViolation(
+                    rule="claude-prefer-xml",
+                    severity="hint",
+                    message=(
+                        "Claude handles XML tags well for structured prompts — "
+                        "try <context>, <instructions>, <constraints>"
+                    ),
+                    prompt_text=text,
+                )
+            )
+
+    elif model == "gpt":
+        # GPT: XML tags may be echoed verbatim; prefer markdown
+        if has_xml:
+            violations.append(
+                LintViolation(
+                    rule="gpt-avoid-xml",
+                    severity="warning",
+                    message=(
+                        "GPT may echo XML tags verbatim — "
+                        "use markdown headers (## Context, ## Instructions) instead"
+                    ),
+                    prompt_text=text,
+                )
+            )
+        # GPT: markdown headers are preferred
+        if not has_md_headers and word_count > 50:
+            violations.append(
+                LintViolation(
+                    rule="gpt-prefer-markdown",
+                    severity="hint",
+                    message=(
+                        "Long prompts for GPT benefit from markdown headers — "
+                        "use ## sections for clarity"
+                    ),
+                    prompt_text=text,
+                )
+            )
+        # GPT: JSON mode needs explicit instruction
+        if _JSON_MODE_RE.search(text) is None and "json" in text.lower():
+            violations.append(
+                LintViolation(
+                    rule="gpt-json-instruction",
+                    severity="warning",
+                    message=(
+                        "GPT requires explicit JSON instruction — "
+                        'add "Respond in JSON format" for reliable JSON output'
+                    ),
+                    prompt_text=text,
+                )
+            )
+
+    elif model == "gemini":
+        # Gemini: very long prompts may lose focus
+        if word_count > 500:
+            violations.append(
+                LintViolation(
+                    rule="gemini-prompt-length",
+                    severity="warning",
+                    message=(
+                        f"Prompt is {word_count} words — "
+                        "Gemini may lose focus on long instructions, consider splitting"
+                    ),
+                    prompt_text=text,
+                )
+            )
+        # Gemini: broad negatives break reasoning (official Gemini 3 guide)
+        if _BROAD_NEGATIVE_RE.search(text):
+            violations.append(
+                LintViolation(
+                    rule="gemini-broad-negative",
+                    severity="warning",
+                    message=(
+                        'Broad negatives ("do not infer/guess/assume") break '
+                        "Gemini's reasoning — use positive instructions instead"
+                    ),
+                    prompt_text=text,
+                )
+            )
+
+    # Cross-model: CoT anti-pattern for reasoning models
+    if model == "gpt" and _COT_RE.search(text):
+        violations.append(
+            LintViolation(
+                rule="gpt-no-cot-reasoning",
+                severity="hint",
+                message=(
+                    '"Think step by step" hurts o-series reasoning models — '
+                    "give high-level goals instead of prescriptive steps"
+                ),
+                prompt_text=text,
+            )
+        )
+
     return violations
 
 
@@ -228,15 +390,19 @@ def format_lint_results(violations: list[LintViolation], total_prompts: int) ->
 
     errors = [v for v in violations if v.severity == "error"]
     warnings = [v for v in violations if v.severity == "warning"]
+    hints = [v for v in violations if v.severity == "hint"]
 
     lines: list[str] = []
     lines.append(f"Checked {total_prompts} prompts\n")
 
     for v in violations:
-        prefix = "✗" if v.severity == "error" else "!"
+        prefix = "✗" if v.severity == "error" else "!" if v.severity == "warning" 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)")
+    parts = [f"{len(errors)} error(s)", f"{len(warnings)} warning(s)"]
+    if hints:
+        parts.append(f"{len(hints)} hint(s)")
+    lines.append(f"\n{', '.join(parts)}")
     return "\n".join(lines)

{reprompt_cli-2.0.2 → reprompt_cli-2.1.0}/src/reprompt/core/scorer.py

@@ -244,28 +244,39 @@ def score_prompt(dna: PromptDNA) -> ScoreBreakdown:
     confirmations: list[Confirmation] = []
     if pos_score >= 0.8:
         confirmations.append(
-            Confirmation("position", "Key instruction at the start — optimal placement",
-                         f"{round(position)}/20")
+            Confirmation(
+                "position",
+                "Key instruction at the start — optimal placement",
+                f"{round(position)}/20",
+            )
         )
     if dna.has_file_references:
         confirmations.append(
-            Confirmation("context", "File references detected — specificity matters",
-                         f"{round(min(context, 25))}/25")
+            Confirmation(
+                "context",
+                "File references detected — specificity matters",
+                f"{round(min(context, 25))}/25",
+            )
         )
     if dna.has_error_messages:
         confirmations.append(
-            Confirmation("context", "Error context included — 3.7x more effective",
-                         f"{round(min(context, 25))}/25")
+            Confirmation(
+                "context",
+                "Error context included — 3.7x more effective",
+                f"{round(min(context, 25))}/25",
+            )
         )
     if dna.has_constraints:
         confirmations.append(
-            Confirmation("structure", "Constraints defined — clear boundaries set",
-                         f"{round(structure)}/15")
+            Confirmation(
+                "structure", "Constraints defined — clear boundaries set", f"{round(structure)}/15"
+            )
         )
     if dna.opening_quality >= 0.4:
         confirmations.append(
-            Confirmation("clarity", "Strong opening — starts with clear intent",
-                         f"{round(clarity)}/25")
+            Confirmation(
+                "clarity", "Strong opening — starts with clear intent", f"{round(clarity)}/25"
+            )
         )
 
     # ── Total ──

{reprompt_cli-2.0.2 → reprompt_cli-2.1.0}/src/reprompt/output/rewrite_terminal.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import difflib
 from io import StringIO
 from typing import TYPE_CHECKING
 
@@ -57,6 +58,52 @@ def render_rewrite(result: RewriteResult) -> str:
     return buf.getvalue()
 
 
+def render_rewrite_diff(result: RewriteResult) -> str:
+    """Render a unified diff between original and rewritten prompt."""
+    buf = StringIO()
+    console = Console(file=buf, width=100, record=True)
+
+    orig_lines = result.original.splitlines(keepends=True)
+    new_lines = result.rewritten.splitlines(keepends=True)
+
+    diff = difflib.unified_diff(
+        orig_lines, new_lines, fromfile="original", tofile="rewritten", lineterm=""
+    )
+
+    console.print()
+    has_diff = False
+    for line in diff:
+        line = line.rstrip("\n")
+        if line.startswith("---"):
+            console.print(f"[bold red]{line}[/bold red]")
+            has_diff = True
+        elif line.startswith("+++"):
+            console.print(f"[bold green]{line}[/bold green]")
+        elif line.startswith("@@"):
+            console.print(f"[cyan]{line}[/cyan]")
+        elif line.startswith("-"):
+            console.print(f"[red]{line}[/red]")
+        elif line.startswith("+"):
+            console.print(f"[green]{line}[/green]")
+        else:
+            console.print(f" {line}")
+
+    if not has_diff:
+        console.print("[dim]No changes — prompt is already optimized.[/dim]")
+
+    # Score summary
+    delta = result.score_delta
+    if delta > 0:
+        delta_str = f"[green]+{delta:.0f}[/green]"
+    elif delta < 0:
+        delta_str = f"[red]{delta:.0f}[/red]"
+    else:
+        delta_str = "[dim]±0[/dim]"
+    console.print(f"\n  Score: {result.score_before:.0f} → {result.score_after:.0f} ({delta_str})")
+    console.print()
+    return buf.getvalue()
+
+
 def _score_color(score: float) -> str:
     if score >= 85:
         return "bold magenta"

{reprompt_cli-2.0.2 → reprompt_cli-2.1.0}/src/reprompt/output/terminal.py

@@ -348,9 +348,7 @@ def render_score(breakdown: dict[str, Any]) -> str:
         else "dim"
     )
 
-    console.print(
-        f"\n[bold]Score: {total:.0f}/100[/bold]  [{tier_color}]{tier}[/{tier_color}]"
-    )
+    console.print(f"\n[bold]Score: {total:.0f}/100[/bold]  [{tier_color}]{tier}[/{tier_color}]")
     cost_info = breakdown.get("estimated_cost")
     if cost_info:
         console.print(