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

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

@@ -2,6 +2,98 @@
 
 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
+- **Project-level quality comparison** — `reprompt projects` aggregates session quality, efficiency, focus scores, and frustration signals per project. Supports `--source` filter, `--json`, `--copy`.
+- Tests: 1670 → 1716
+
+## [2.0.0] - 2026-03-31
+
+### Changed
+- **Major version bump** — the rewrite engine marks the shift from passive analysis (v1.x) to active prompt coaching (v2.0). reprompt now scores, rewrites, and optimizes your AI prompts automatically.
+
+## [1.10.0] - 2026-03-31
+
+### Added
+- **Prompt rewrite engine** — `reprompt rewrite "prompt"` applies 4 rule-based transformations: filler removal (reuses compress engine), instruction front-loading (Stanford position bias), key requirement echo (Google repetition research), hedging cleanup (12 regex patterns). Shows before/after score delta and manual suggestions. No LLM needed, under 50ms.
+- **`reprompt init` command** — generates `.reprompt.toml` config with all lint rules documented and commented defaults. `--force` to overwrite existing.
+- Tests: 1597 → 1670
+
+## [1.9.1] - 2026-03-31
+
+### Added
+- **Configurable lint rules** — `.reprompt.toml` or `[tool.reprompt.lint]` in `pyproject.toml`. Supports `score-threshold`, `min-length`, `short-prompt`, `vague-prompt`, `debug-needs-reference`, `file-extensions`. Config walks up from CWD. CLI flags override file config.
+- Tests: 1567 → 1597
+
+## [1.9.0] - 2026-03-31
+
+### Added
+- **Bidirectional bridge** — Native Messaging `sync_result` now returns insights (avg score, score trend, top coaching tip) back to the browser extension. New `get_insights` message type for full analysis including repetition data and pattern info.
+- `get_recent_scores(limit)` DB method for trend computation.
+- Tests: 1545 → 1567
+
+## [1.8.1] - 2026-03-31
+
+### Added
+- **Cross-session repetition detection** — `reprompt repetition` detects recurring prompts across different AI sessions using TF-IDF + containment clustering (threshold 0.75). Shows repetition rate, recurring topics ranked by session count, and date ranges. Integrated into `reprompt insights` output.
+- Tests: 1529 → 1545
+
+## [1.8.0] - 2026-03-31
+
+### Added
+- **Session quality metrics** — `reprompt sessions` provides composite 0-100 session scoring combining prompt quality, efficiency, focus, and outcome. Frustration signal detection: abandonment, escalation, stall turns. Rich table and detail views.
+
+### Fixed
+- **Pipeline type mismatch** — `parse_conversation()` returns `list[ConversationTurn]`, not `Conversation`. Pipeline now wraps turns correctly. Without this fix, session quality scoring silently failed.
+- **Bridge shell injection** — quoted `sys.executable` in bridge wrapper script to prevent command injection when Python path contains spaces.
+- **Unclamped scores** — efficiency and focus component scores now clamped to 0-100 range.
+- Tests: 1497 → 1529
+
+## [1.7.1] - 2026-03-29
+
+### Added
+- **Expanded privacy scanner** — 10 new detection patterns: SSH private keys (RSA/EC/DSA/OPENSSH/PKCS#8), PEM certificates, service tokens (Slack bot/user/app, Google API, npm), database connection strings (PostgreSQL, MySQL, MongoDB, Redis). 28 new tests. Closes #12.
+
+## [1.7.0] - 2026-03-28
+
+### Added
+- **GitHub Action PR comments** — `comment-on-pr: true` posts quality report as PR comment with markdown table, collapsible violations, and score summary. Updates existing comment on re-push (no duplicates).
+- **Token cost estimation** — `reprompt score` shows ~tokens and $cost. `reprompt insights` shows total prompt cost. `reprompt report` overview includes estimated cost. MCP `score_prompt` includes token count and cost.
+- Locale-aware token counting: 1.3x words (EN), 1.5x chars (CJK).
+- Price table: Claude Sonnet/Opus/Haiku, GPT-4o/mini, Gemini, DeepSeek. Auto-detect model from adapter source.
+- Tests: 1497 → 1529
+
+## [1.6.2] - 2026-03-28
+
+### Fixed
+- **Security: shell injection in GitHub Action** — inputs now passed via env vars, not string interpolation.
+- **Bridge: 1MB message limit** — enforce Chrome Native Messaging size limit with proper JSON decode error handling.
+
+### Improved
+- SQLite WAL mode + 10s timeout for concurrent access safety.
+- MCP: all 6 tools wrapped in try/except with structured error responses; `check_privacy` uses SQL LIMIT.
+- Dedup: skip O(n²) semantic layer when batch > 5000 prompts.
+- ChatGPT adapter: warn on files > 200MB.
+- First-run dashboard shows "Found N sessions (~M turns) across K tools".
+- `purge --all` now requires confirmation.
+- MCP server consolidated from 10 to 6 focused tools.
+
 ## [1.6.1] - 2026-03-28
 
 ### Fixed

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reprompt-cli
-Version: 2.0.1
+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
@@ -111,6 +111,7 @@ $ reprompt
 | `reprompt agent` | Agent workflow analysis -- error loops, tool patterns, session efficiency |
 | `reprompt sessions` | Session quality scores with frustration signal detection |
 | `reprompt repetition` | Cross-session repetition detection -- spot recurring prompts |
+| `reprompt projects` | Per-project quality breakdown -- sessions, scores, frustration signals |
 
 ### Optimize
 
@@ -200,7 +201,7 @@ reprompt install-hook               # adds post-session hook to Claude Code
 
 ### Browser extension
 
-Capture prompts from ChatGPT, Claude.ai, and Gemini directly in your browser:
+Capture prompts from ChatGPT, Claude.ai, and Gemini directly in your browser. Live score badge shows prompt quality as you type.
 
 1. **Install the extension** from [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn) or [Firefox Add-ons](https://addons.mozilla.org/addon/reprompt-cli/)
 2. **Connect to the CLI:** `reprompt install-extension`
@@ -227,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: v1.7.0
+    rev: v2.1.0
     hooks:
       - id: reprompt-lint
 ```

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

@@ -66,6 +66,7 @@ $ reprompt
 | `reprompt agent` | Agent workflow analysis -- error loops, tool patterns, session efficiency |
 | `reprompt sessions` | Session quality scores with frustration signal detection |
 | `reprompt repetition` | Cross-session repetition detection -- spot recurring prompts |
+| `reprompt projects` | Per-project quality breakdown -- sessions, scores, frustration signals |
 
 ### Optimize
 
@@ -155,7 +156,7 @@ reprompt install-hook               # adds post-session hook to Claude Code
 
 ### Browser extension
 
-Capture prompts from ChatGPT, Claude.ai, and Gemini directly in your browser:
+Capture prompts from ChatGPT, Claude.ai, and Gemini directly in your browser. Live score badge shows prompt quality as you type.
 
 1. **Install the extension** from [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn) or [Firefox Add-ons](https://addons.mozilla.org/addon/reprompt-cli/)
 2. **Connect to the CLI:** `reprompt install-extension`
@@ -182,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: v1.7.0
+    rev: v2.1.0
     hooks:
       - id: reprompt-lint
 ```

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

@@ -1,6 +1,6 @@
 [project]
 name = "reprompt-cli"
-version = "2.0.1"
+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.1 → reprompt_cli-2.1.0}/src/reprompt/__init__.py

@@ -1,6 +1,6 @@
 """reprompt — Discover, analyze, and evolve your best prompts from AI coding sessions."""
 
-__version__ = "2.0.1"
+__version__ = "2.0.2"
 
 __all__ = [
     "__version__",
@@ -19,11 +19,11 @@ def _grade(total: float) -> str:
     """Map 0-100 score to letter grade."""
     if total >= 85:
         return "A"
-    if total >= 70:
+    if total >= 60:
         return "B"
-    if total >= 55:
-        return "C"
     if total >= 40:
+        return "C"
+    if total >= 25:
         return "D"
     return "F"
 

{reprompt_cli-2.0.1 → 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()
@@ -982,9 +1000,18 @@ def score(
                     "paper": s.paper,
                     "message": s.message,
                     "impact": s.impact,
+                    "points": s.points,
                 }
                 for s in breakdown.suggestions
             ],
+            "confirmations": [
+                {
+                    "category": c.category,
+                    "message": c.message,
+                    "score": c.score,
+                }
+                for c in breakdown.confirmations
+            ],
         }
         typer.echo(json_mod.dumps(data, indent=2))
     else:
@@ -1004,9 +1031,18 @@ def score(
                     "paper": s.paper,
                     "message": s.message,
                     "impact": s.impact,
+                    "points": s.points,
                 }
                 for s in breakdown.suggestions
             ],
+            "confirmations": [
+                {
+                    "category": c.category,
+                    "message": c.message,
+                    "score": c.score,
+                }
+                for c in breakdown.confirmations
+            ],
         }
         typer.echo(render_score(data))
         from reprompt.core.suggestions import get_suggestion
@@ -1069,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.
@@ -1081,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
 
@@ -1102,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
 
@@ -2024,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.1 → 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)