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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reprompt-cli
-Version: 1.9.1
+Version: 1.10.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
@@ -96,6 +96,8 @@ $ reprompt compress "I was wondering if you could please help me refactor this c
 | `reprompt insights` | Personal patterns vs research-optimal benchmarks |
 | `reprompt style` | Prompting fingerprint with `--trends` for evolution tracking |
 | `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 |
 
 ### Optimize
 
@@ -104,7 +106,8 @@ $ reprompt compress "I was wondering if you could please help me refactor this c
 | `reprompt compress "prompt"` | 4-layer prompt compression (40-60% token savings typical) |
 | `reprompt distill` | Extract important turns from conversations with 6-signal scoring |
 | `reprompt distill --export` | Recover context when a session runs out -- paste into new session |
-| `reprompt lint` | Prompt quality linter with GitHub Action support |
+| `reprompt lint` | Configurable prompt quality linter with CI/GitHub Action support |
+| `reprompt init` | Generate `.reprompt.toml` config for your project |
 
 ### Manage
 
@@ -223,6 +226,24 @@ reprompt lint --strict              # exit 1 on warnings
 reprompt lint --json                # machine-readable output
 ```
 
+#### Project configuration
+
+```bash
+reprompt init   # generates .reprompt.toml with all rules documented
+```
+
+```toml
+# .reprompt.toml (or [tool.reprompt.lint] in pyproject.toml)
+[lint]
+score-threshold = 50       # fail if avg score < 50
+
+[lint.rules]
+min-length = 20            # error if prompt < 20 chars (0 = off)
+short-prompt = 40          # warning if < 40 chars (0 = off)
+vague-prompt = true        # error on "fix it" etc (false = off)
+debug-needs-reference = true
+```
+
 ## Privacy
 
 - All analysis runs locally. No prompts leave your machine.

{reprompt_cli-1.9.1 → reprompt_cli-1.10.0}/README.md

@@ -51,6 +51,8 @@ $ reprompt compress "I was wondering if you could please help me refactor this c
 | `reprompt insights` | Personal patterns vs research-optimal benchmarks |
 | `reprompt style` | Prompting fingerprint with `--trends` for evolution tracking |
 | `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 |
 
 ### Optimize
 
@@ -59,7 +61,8 @@ $ reprompt compress "I was wondering if you could please help me refactor this c
 | `reprompt compress "prompt"` | 4-layer prompt compression (40-60% token savings typical) |
 | `reprompt distill` | Extract important turns from conversations with 6-signal scoring |
 | `reprompt distill --export` | Recover context when a session runs out -- paste into new session |
-| `reprompt lint` | Prompt quality linter with GitHub Action support |
+| `reprompt lint` | Configurable prompt quality linter with CI/GitHub Action support |
+| `reprompt init` | Generate `.reprompt.toml` config for your project |
 
 ### Manage
 
@@ -178,6 +181,24 @@ reprompt lint --strict              # exit 1 on warnings
 reprompt lint --json                # machine-readable output
 ```
 
+#### Project configuration
+
+```bash
+reprompt init   # generates .reprompt.toml with all rules documented
+```
+
+```toml
+# .reprompt.toml (or [tool.reprompt.lint] in pyproject.toml)
+[lint]
+score-threshold = 50       # fail if avg score < 50
+
+[lint.rules]
+min-length = 20            # error if prompt < 20 chars (0 = off)
+short-prompt = 40          # warning if < 40 chars (0 = off)
+vague-prompt = true        # error on "fix it" etc (false = off)
+debug-needs-reference = true
+```
+
 ## Privacy
 
 - All analysis runs locally. No prompts leave your machine.

{reprompt_cli-1.9.1 → reprompt_cli-1.10.0}/pyproject.toml

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

{reprompt_cli-1.9.1 → reprompt_cli-1.10.0}/src/reprompt/__init__.py

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

{reprompt_cli-1.9.1 → reprompt_cli-1.10.0}/src/reprompt/cli.py

@@ -1065,6 +1065,58 @@ def compress(
         _copy_to_clip(result.compressed, quiet=json_output)
 
 
+@app.command(rich_help_panel="Optimize")
+def rewrite(
+    text: str = typer.Argument(..., help="Prompt text to improve"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    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.
+
+    Applies 4 layers: filler removal, instruction front-loading,
+    key requirement echo, and hedging cleanup. Also suggests manual
+    improvements you can make.
+
+    Examples:
+
+        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" --json
+    """
+    from reprompt.core.rewrite import rewrite_prompt
+
+    result = rewrite_prompt(text)
+
+    if json_output:
+        import json as json_mod
+
+        data = {
+            "original": result.original,
+            "rewritten": result.rewritten,
+            "score_before": result.score_before,
+            "score_after": result.score_after,
+            "score_delta": result.score_delta,
+            "changes": result.changes,
+            "manual_suggestions": result.manual_suggestions,
+        }
+        typer.echo(json_mod.dumps(data, indent=2, ensure_ascii=False))
+    else:
+        from reprompt.output.rewrite_terminal import render_rewrite
+
+        typer.echo(render_rewrite(result))
+
+    if copy:
+        _copy_to_clip(result.rewritten, quiet=json_output)
+
+    from reprompt.core.suggestions import get_suggestion
+
+    hint = get_suggestion("rewrite")
+    if hint and not json_output:
+        console.print(f"  [dim]→ Try: {hint}[/dim]\n")
+
+
 @app.command(rich_help_panel="Optimize")
 def distill(
     session_id: str = typer.Argument(None, help="Session ID to distill"),
@@ -1935,6 +1987,65 @@ def extension_status() -> None:
         console.print("  Last sync:         never")
 
 
+@app.command(rich_help_panel="Setup")
+def init(
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing config"),
+) -> None:
+    """Generate a .reprompt.toml config file in the current directory.
+
+    Creates a starter config with all lint rules documented and commented.
+    Use this to customize reprompt for your project or CI pipeline.
+
+    Examples:
+
+        reprompt init                     # create .reprompt.toml
+
+        reprompt init --force             # overwrite existing config
+    """
+    config_path = Path.cwd() / ".reprompt.toml"
+
+    if config_path.exists() and not force:
+        console.print(
+            f"[yellow]{config_path.name} already exists.[/yellow]"
+            " Use [bold]--force[/bold] to overwrite."
+        )
+        raise typer.Exit(1)
+
+    config_content = """\
+# reprompt configuration
+# Docs: https://github.com/reprompt-dev/reprompt
+#
+# This file configures `reprompt lint` rules and CI thresholds.
+# Place in your project root — reprompt walks up from CWD to find it.
+# Alternatively, add [tool.reprompt.lint] to pyproject.toml.
+
+[lint]
+# Fail `reprompt lint` if average prompt score < threshold (0 = disabled)
+# Useful for CI: reprompt lint --score-threshold reads this value
+# score-threshold = 50
+
+[lint.rules]
+# min-length: error if prompt < N chars (0 = disabled)
+min-length = 20
+
+# short-prompt: warning if prompt < N chars (0 = disabled)
+short-prompt = 40
+
+# vague-prompt: error on vague prompts like "fix it" (false = disabled)
+vague-prompt = true
+
+# debug-needs-reference: warning if debug prompt lacks file reference (false = disabled)
+debug-needs-reference = true
+
+# file-extensions: extensions recognized as file references
+# file-extensions = [".py", ".ts", ".js", ".go", ".rs", ".java", ".rb", ".cpp", ".c"]
+"""
+
+    config_path.write_text(config_content)
+    console.print(f"[green]Created[/green] {config_path.name}")
+    console.print("  Edit rules, then run [bold]reprompt lint[/bold] to verify.")
+
+
 @app.command(rich_help_panel="Analyze")
 def sessions(
     last: int = typer.Option(10, "--last", help="Show N most recent sessions"),

reprompt_cli-1.10.0/src/reprompt/core/rewrite.py

@@ -0,0 +1,221 @@
+"""Rule-based prompt rewrite engine.
+
+Transforms low-scoring prompts into better versions using research-backed
+rules. No LLM required — pure regex + structural transforms.
+
+Layers:
+1. Compress — remove filler (reuse compress engine)
+2. Restructure — front-load instructions (move imperative to start)
+3. Reinforce — echo key requirement at end for long prompts
+4. Annotate — suggest what the user should add manually
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+
+@dataclass
+class RewriteResult:
+    """Result of rewriting a prompt."""
+
+    original: str
+    rewritten: str
+    changes: list[str] = field(default_factory=list)
+    manual_suggestions: list[str] = field(default_factory=list)
+    score_before: float = 0.0
+    score_after: float = 0.0
+    score_delta: float = 0.0
+
+
+def rewrite_prompt(text: str) -> RewriteResult:
+    """Rewrite a prompt to improve its score. Returns before/after with changes."""
+    from reprompt.core.compress import compress_text
+    from reprompt.core.extractors import extract_features
+    from reprompt.core.scorer import score_prompt
+    from reprompt.core.segmenter import segment_prompt
+
+    # Score original
+    dna = extract_features(text, source="rewrite", session_id="")
+    score_before = score_prompt(dna)
+
+    result = text
+    changes: list[str] = []
+
+    # Layer 1: Compress (filler removal)
+    compressed = compress_text(result)
+    if compressed.savings_pct > 5:
+        result = compressed.compressed
+        changes.append(f"Removed filler ({compressed.savings_pct:.0f}% shorter)")
+
+    # Layer 2: Front-load instruction (if buried in middle)
+    if dna.key_instruction_position > 0.3:
+        segments = segment_prompt(result)
+        new_result = _front_load_instruction(result, segments)
+        if new_result != result:
+            result = new_result
+            changes.append("Moved main instruction to front")
+
+    # Layer 3: Echo key requirement (for long prompts with low repetition)
+    current_word_count = len(result.split())
+    if dna.keyword_repetition_freq < 0.15 and current_word_count > 40:
+        echoed = _echo_key_requirement(result)
+        if echoed != result:
+            result = echoed
+            changes.append("Echoed key requirement at end")
+
+    # Layer 4: Clarity — replace hedge phrases
+    cleaned = _remove_hedging(result)
+    if cleaned != result:
+        result = cleaned
+        changes.append("Removed hedging language")
+
+    # Score rewritten
+    dna_after = extract_features(result, source="rewrite", session_id="")
+    score_after = score_prompt(dna_after)
+
+    # Generate manual suggestions for things we can't auto-fix
+    manual = _generate_manual_suggestions(dna)
+
+    return RewriteResult(
+        original=text,
+        rewritten=result,
+        changes=changes,
+        manual_suggestions=manual,
+        score_before=score_before.total,
+        score_after=score_after.total,
+        score_delta=round(score_after.total - score_before.total, 1),
+    )
+
+
+def _front_load_instruction(text: str, segments: list) -> str:
+    """Move the first instruction segment to the front of the prompt."""
+    instruction_seg = None
+    instruction_idx = -1
+
+    for i, seg in enumerate(segments):
+        if seg.segment_type == "instruction" and seg.start_pos > 0.2:
+            instruction_seg = seg
+            instruction_idx = i
+            break
+
+    if instruction_seg is None:
+        return text
+
+    # Extract the instruction text and rebuild
+    inst_text = instruction_seg.text.strip()
+    # Remove the instruction from its original position
+    remaining_parts = []
+    for i, seg in enumerate(segments):
+        if i == instruction_idx:
+            continue
+        remaining_parts.append(seg.text.strip())
+
+    remaining = "\n\n".join(p for p in remaining_parts if p)
+
+    # Ensure instruction ends with period for clean sentence
+    if inst_text and inst_text[-1] not in ".!?":
+        inst_text = inst_text + "."
+
+    return f"{inst_text}\n\n{remaining}".strip()
+
+
+def _echo_key_requirement(text: str) -> str:
+    """Add a reinforcement of the key requirement at the end."""
+    # Extract the most important action phrase from the first sentence
+    lines = text.strip().split("\n")
+    first_line = ""
+    for line in lines:
+        stripped = line.strip()
+        if stripped and not stripped.startswith("#") and not stripped.startswith("```"):
+            first_line = stripped
+            break
+
+    if not first_line or len(first_line) < 10:
+        return text
+
+    # Extract the core verb+object phrase
+    key_phrase = _extract_key_phrase(first_line)
+    if not key_phrase or len(key_phrase) < 8:
+        return text
+
+    # Don't echo if text already ends with similar content
+    last_100 = text[-100:].lower()
+    if key_phrase.lower() in last_100:
+        return text
+
+    return f"{text.rstrip()}\n\nImportant: {key_phrase}."
+
+
+def _extract_key_phrase(sentence: str) -> str:
+    """Extract the core verb+object from a sentence."""
+    # Remove leading filler
+    cleaned = re.sub(
+        r"^(?:please\s+|can you\s+|could you\s+|i need you to\s+|i want you to\s+|"
+        r"i would like you to\s+|help me\s+)",
+        "",
+        sentence.strip(),
+        flags=re.IGNORECASE,
+    )
+    # Take the main clause (before first comma or period)
+    main = re.split(r"[,.]", cleaned)[0].strip()
+    # Cap length
+    if len(main) > 80:
+        words = main.split()
+        main = " ".join(words[:12])
+    return main
+
+
+_HEDGE_PATTERNS = [
+    (re.compile(r"\bI was wondering if you could\b", re.IGNORECASE), ""),
+    (re.compile(r"\bI think maybe\b", re.IGNORECASE), ""),
+    (re.compile(r"\bif possible,?\s*", re.IGNORECASE), ""),
+    (re.compile(r"\bif you don'?t mind,?\s*", re.IGNORECASE), ""),
+    (re.compile(r"\bbasically,?\s*", re.IGNORECASE), ""),
+    (re.compile(r"\bkind of\b", re.IGNORECASE), ""),
+    (re.compile(r"\bsort of\b", re.IGNORECASE), ""),
+    (re.compile(r"\bjust\s+", re.IGNORECASE), ""),
+    (re.compile(r"\bmaybe\s+", re.IGNORECASE), ""),
+    (re.compile(r"\bperhaps\s+", re.IGNORECASE), ""),
+    (re.compile(r"\ba little bit\b", re.IGNORECASE), ""),
+    (re.compile(r"\bI guess\s+", re.IGNORECASE), ""),
+]
+
+
+def _remove_hedging(text: str) -> str:
+    """Remove hedging language that weakens the prompt."""
+    result = text
+    for pattern, replacement in _HEDGE_PATTERNS:
+        result = pattern.sub(replacement, result)
+    # Clean up double spaces
+    result = re.sub(r"  +", " ", result)
+    # Clean up leading spaces on lines
+    lines = result.split("\n")
+    result = "\n".join(line.lstrip() if line.strip() else line for line in lines)
+    return result
+
+
+def _generate_manual_suggestions(dna: object) -> list[str]:
+    """Generate suggestions for improvements that require human input."""
+    suggestions: list[str] = []
+
+    specificity = getattr(dna, "context_specificity", 1.0)
+    if specificity < 0.4:
+        suggestions.append("Add actual code snippets or error messages for context")
+
+    if not getattr(dna, "has_constraints", True):
+        suggestions.append('Add constraints (e.g., "Do not modify existing tests")')
+
+    if not getattr(dna, "has_output_format", True):
+        suggestions.append("Specify expected output format (e.g., JSON, code block)")
+
+    if not getattr(dna, "has_file_references", True):
+        task = getattr(dna, "task_type", "")
+        if task in ("debug", "implement", "refactor", "test"):
+            suggestions.append("Reference specific files or functions by name")
+
+    if not getattr(dna, "has_examples", True):
+        suggestions.append("Add an example of expected input/output")
+
+    return suggestions

{reprompt_cli-1.9.1 → reprompt_cli-1.10.0}/src/reprompt/core/suggestions.py

@@ -22,6 +22,8 @@ SUGGESTIONS: dict[str, str] = {
         'reprompt template save "..." (reuse patterns) · reprompt insights (all patterns)'
     ),
     "template": "reprompt insights (see which patterns work best)",
+    "lint": "reprompt init (generate .reprompt.toml) · reprompt rewrite (improve prompts)",
+    "rewrite": "reprompt compress (reduce tokens) · reprompt score (verify improvement)",
 }
 
 

reprompt_cli-1.10.0/src/reprompt/output/rewrite_terminal.py

@@ -0,0 +1,69 @@
+"""Rich terminal output for rewrite command."""
+
+from __future__ import annotations
+
+from io import StringIO
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+from rich.panel import Panel
+
+if TYPE_CHECKING:
+    from reprompt.core.rewrite import RewriteResult
+
+
+def render_rewrite(result: RewriteResult) -> str:
+    """Render a rewrite result as a Rich-formatted string."""
+    buf = StringIO()
+    console = Console(file=buf, width=100, record=True)
+
+    # Score change header
+    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]"
+
+    before_color = _score_color(result.score_before)
+    after_color = _score_color(result.score_after)
+
+    console.print(
+        f"\n  [{before_color}]{result.score_before:.0f}[/{before_color}]"
+        f" → [{after_color}]{result.score_after:.0f}[/{after_color}]"
+        f" ({delta_str})\n"
+    )
+
+    # Rewritten prompt
+    if result.changes:
+        console.print(Panel(result.rewritten, title="Rewritten", border_style="green"))
+    else:
+        console.print("[dim]No automated improvements found.[/dim]")
+
+    # Changes applied
+    if result.changes:
+        console.print("\n  [bold]Changes[/bold]")
+        for change in result.changes:
+            console.print(f"  [green]✓[/green] {change}")
+
+    # Manual suggestions
+    if result.manual_suggestions:
+        console.print("\n  [bold]You should also[/bold]")
+        for s in result.manual_suggestions:
+            console.print(f"  [yellow]→[/yellow] {s}")
+
+    console.print()
+    return buf.getvalue()
+
+
+def _score_color(score: float) -> str:
+    if score >= 85:
+        return "bold magenta"
+    if score >= 70:
+        return "bold green"
+    if score >= 55:
+        return "bold yellow"
+    if score >= 40:
+        return "yellow"
+    return "bold red"

reprompt_cli-1.10.0/tests/test_init_cli.py

@@ -0,0 +1,80 @@
+"""Tests for reprompt init command."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from reprompt.cli import app
+
+runner = CliRunner()
+
+
+def test_init_creates_config(tmp_path: Path) -> None:
+    os.chdir(tmp_path)
+    result = runner.invoke(app, ["init"])
+    assert result.exit_code == 0
+    config = tmp_path / ".reprompt.toml"
+    assert config.exists()
+    content = config.read_text()
+    assert "[lint]" in content
+    assert "[lint.rules]" in content
+    assert "min-length" in content
+
+
+def test_init_refuses_overwrite(tmp_path: Path) -> None:
+    os.chdir(tmp_path)
+    (tmp_path / ".reprompt.toml").write_text("existing")
+    result = runner.invoke(app, ["init"])
+    assert result.exit_code == 1
+    assert "already exists" in result.output
+    # Original content preserved
+    assert (tmp_path / ".reprompt.toml").read_text() == "existing"
+
+
+def test_init_force_overwrites(tmp_path: Path) -> None:
+    os.chdir(tmp_path)
+    (tmp_path / ".reprompt.toml").write_text("old content")
+    result = runner.invoke(app, ["init", "--force"])
+    assert result.exit_code == 0
+    content = (tmp_path / ".reprompt.toml").read_text()
+    assert "[lint]" in content
+    assert "old content" not in content
+
+
+def test_init_config_is_valid_toml(tmp_path: Path) -> None:
+    """Generated config should be parseable TOML."""
+    import sys
+
+    if sys.version_info >= (3, 11):
+        import tomllib
+    else:
+        try:
+            import tomllib
+        except ModuleNotFoundError:
+            import tomli as tomllib  # type: ignore[no-redefine]
+
+    os.chdir(tmp_path)
+    runner.invoke(app, ["init"])
+    with open(tmp_path / ".reprompt.toml", "rb") as f:
+        data = tomllib.load(f)
+    assert "lint" in data
+    assert "rules" in data["lint"]
+    assert data["lint"]["rules"]["min-length"] == 20
+    assert data["lint"]["rules"]["vague-prompt"] is True
+
+
+def test_init_config_works_with_lint(tmp_path: Path) -> None:
+    """Generated config should be loadable by lint config loader."""
+    os.chdir(tmp_path)
+    runner.invoke(app, ["init"])
+
+    from reprompt.core.lint import load_lint_config
+
+    config = load_lint_config(start_dir=tmp_path)
+    assert config.min_length == 20
+    assert config.short_prompt == 40
+    assert config.vague_prompt is True
+    assert config.debug_needs_reference is True