reprompt-cli 2.3.0__tar.gz → 2.4.0__tar.gz

{reprompt_cli-2.3.0 → reprompt_cli-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reprompt-cli
-Version: 2.3.0
+Version: 2.4.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

{reprompt_cli-2.3.0 → reprompt_cli-2.4.0}/pyproject.toml

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

{reprompt_cli-2.3.0 → reprompt_cli-2.4.0}/src/reprompt/cli.py

@@ -2400,6 +2400,38 @@ def sessions(
         _copy_to_clip(copy_text, quiet=json_output)
 
 
+@app.command(rich_help_panel="Analyze")
+def patterns(
+    last: int = typer.Option(500, "--last", help="Analyze N most recent prompts"),
+    source: str = typer.Option(
+        None, "--source", "-s", help="Filter by source (e.g. claude-code, cursor)"
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    copy: bool = typer.Option(False, "--copy", help="Copy result to clipboard"),
+) -> None:
+    """Discover your personal prompt weaknesses and recurring gaps."""
+    import json as json_mod
+    from dataclasses import asdict
+
+    from reprompt.config import Settings
+    from reprompt.core.patterns import analyze_patterns
+    from reprompt.output.patterns_terminal import render_patterns
+    from reprompt.storage.db import PromptDB
+
+    settings = Settings()
+    db = PromptDB(settings.db_path)
+    report = analyze_patterns(db, source=source, limit=last)
+
+    if json_output:
+        typer.echo(json_mod.dumps(asdict(report), indent=2, default=str))
+    else:
+        typer.echo(render_patterns(report), nl=False)
+
+    if copy:
+        copy_text = json_mod.dumps(asdict(report), indent=2, default=str)
+        _copy_to_clip(copy_text, quiet=json_output)
+
+
 @app.command(rich_help_panel="Analyze")
 def repetition(
     last: int = typer.Option(500, "--last", help="Analyze N most recent unique prompts"),

reprompt_cli-2.4.0/src/reprompt/core/patterns.py

@@ -0,0 +1,186 @@
+"""Personal prompt patterns — analyze recurring weaknesses in prompt history.
+
+Reads PromptDNA features from the database and identifies systematic gaps
+the user keeps making. Example: "63% of your debug prompts lack error messages."
+
+This is NOT template-based. It uses the user's OWN history to find patterns,
+making suggestions personalized rather than generic.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class TaskPattern:
+    """Analysis of prompts for a single task type."""
+
+    task_type: str
+    count: int
+    avg_score: float
+    # Feature gap rates (0.0 = always present, 1.0 = always missing)
+    gaps: list[FeatureGap] = field(default_factory=list)
+
+
+@dataclass
+class FeatureGap:
+    """A frequently missing feature for a task type."""
+
+    feature: str
+    label: str  # human-readable
+    missing_rate: float  # 0.0-1.0
+    impact: str  # "high", "medium", "low"
+    suggestion: str  # actionable advice
+
+
+@dataclass
+class PatternsReport:
+    """Complete personal prompt patterns analysis."""
+
+    total_analyzed: int
+    task_distribution: dict[str, int]  # task_type → count
+    patterns: list[TaskPattern]
+    top_gaps: list[FeatureGap]  # cross-task most common gaps
+
+
+# Feature checks: (field_name, human_label, applicable_task_types, impact)
+_FEATURE_CHECKS: list[tuple[str, str, list[str], str]] = [
+    ("has_error_messages", "error messages", ["debug"], "high"),
+    ("has_file_references", "file references", ["debug", "implement", "refactor", "test"], "high"),
+    ("has_code_blocks", "code blocks", ["debug", "implement"], "medium"),
+    ("has_constraints", "constraints", ["implement", "refactor", "review"], "high"),
+    ("has_io_spec", "I/O specifications", ["implement", "test"], "medium"),
+    ("has_edge_cases", "edge cases", ["implement", "test"], "medium"),
+    ("has_examples", "examples", ["implement", "test"], "medium"),
+    ("has_output_format", "output format", ["implement", "review", "summarize"], "low"),
+    ("has_role_definition", "role definition", ["review", "creative"], "low"),
+    ("has_step_by_step", "step-by-step structure", ["implement", "refactor"], "low"),
+]
+
+_SUGGESTIONS: dict[str, str] = {
+    "has_error_messages": 'Include the error message: "Error: <paste stack trace>"',
+    "has_file_references": 'Reference files: "in src/auth/middleware.ts"',
+    "has_code_blocks": "Paste the relevant code in a ``` block",
+    "has_constraints": 'Add constraints: "Do not modify existing tests"',
+    "has_io_spec": 'Specify input/output: "Takes a user ID, returns a JWT token"',
+    "has_edge_cases": 'Mention edge cases: "Handle empty input and null values"',
+    "has_examples": "Add an example of expected input/output",
+    "has_output_format": 'Specify format: "Return as JSON with fields..."',
+    "has_role_definition": 'Set a role: "You are a security-focused code reviewer"',
+    "has_step_by_step": 'Request steps: "Break this into incremental steps"',
+}
+
+
+def analyze_patterns(
+    db: Any,
+    *,
+    source: str | None = None,
+    limit: int = 500,
+) -> PatternsReport:
+    """Analyze personal prompt patterns from stored PromptDNA features."""
+    conn = db._conn()
+    try:
+        if source:
+            rows = conn.execute(
+                "SELECT pf.features_json, pf.overall_score, pf.task_type "
+                "FROM prompt_features pf "
+                "JOIN prompts p ON pf.prompt_hash = p.hash "
+                "WHERE p.source = ? "
+                "ORDER BY pf.rowid DESC LIMIT ?",
+                (source, limit),
+            ).fetchall()
+        else:
+            rows = conn.execute(
+                "SELECT features_json, overall_score, task_type "
+                "FROM prompt_features "
+                "ORDER BY rowid DESC LIMIT ?",
+                (limit,),
+            ).fetchall()
+    finally:
+        conn.close()
+
+    if not rows:
+        return PatternsReport(
+            total_analyzed=0,
+            task_distribution={},
+            patterns=[],
+            top_gaps=[],
+        )
+
+    # Parse features and group by task type
+    by_task: dict[str, list[dict[str, Any]]] = {}
+    task_scores: dict[str, list[float]] = {}
+
+    for row in rows:
+        features = json.loads(row["features_json"])
+        task = row["task_type"] or "other"
+        by_task.setdefault(task, []).append(features)
+        task_scores.setdefault(task, []).append(float(row["overall_score"] or 0))
+
+    task_distribution = {t: len(prompts) for t, prompts in by_task.items()}
+
+    # Analyze each task type
+    patterns: list[TaskPattern] = []
+    all_gaps: list[FeatureGap] = []
+
+    for task_type, feature_list in by_task.items():
+        count = len(feature_list)
+        if count < 3:  # need enough data for meaningful patterns
+            continue
+
+        avg_score = sum(task_scores[task_type]) / count
+        gaps: list[FeatureGap] = []
+
+        for field_name, label, applicable_tasks, impact in _FEATURE_CHECKS:
+            if task_type not in applicable_tasks:
+                continue
+
+            # Count how often this feature is missing
+            missing = sum(1 for f in feature_list if not f.get(field_name, False))
+            missing_rate = missing / count
+
+            # Only report if missing >40% of the time
+            if missing_rate > 0.4:
+                gap = FeatureGap(
+                    feature=field_name,
+                    label=label,
+                    missing_rate=round(missing_rate, 2),
+                    impact=impact,
+                    suggestion=_SUGGESTIONS.get(field_name, f"Add {label}"),
+                )
+                gaps.append(gap)
+                all_gaps.append(gap)
+
+        # Sort by missing rate descending
+        gaps.sort(key=lambda g: g.missing_rate, reverse=True)
+
+        patterns.append(
+            TaskPattern(
+                task_type=task_type,
+                count=count,
+                avg_score=round(avg_score, 1),
+                gaps=gaps[:5],  # top 5 gaps per task
+            )
+        )
+
+    # Sort patterns by count (most common task types first)
+    patterns.sort(key=lambda p: p.count, reverse=True)
+
+    # Deduplicate and sort top_gaps across all tasks
+    seen: set[str] = set()
+    top_gaps: list[FeatureGap] = []
+    all_gaps.sort(key=lambda g: g.missing_rate, reverse=True)
+    for gap in all_gaps:
+        if gap.feature not in seen:
+            seen.add(gap.feature)
+            top_gaps.append(gap)
+
+    return PatternsReport(
+        total_analyzed=len(rows),
+        task_distribution=task_distribution,
+        patterns=patterns,
+        top_gaps=top_gaps[:5],
+    )

{reprompt_cli-2.3.0 → reprompt_cli-2.4.0}/src/reprompt/core/rewrite.py

@@ -7,7 +7,8 @@ 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
+4. Clarity — remove hedging language
+5. Task-specific — append structural scaffolding based on detected task type
 """
 
 from __future__ import annotations
@@ -71,6 +72,12 @@ def rewrite_prompt(text: str) -> RewriteResult:
         result = cleaned
         changes.append("Removed hedging language")
 
+    # Layer 5: Task-specific scaffolding
+    scaffolded = _apply_task_scaffold(result, dna)
+    if scaffolded != result:
+        result = scaffolded
+        changes.append(f"Added {dna.task_type} prompt structure")
+
     # Score rewritten
     dna_after = extract_features(result, source="rewrite", session_id="")
     score_after = score_prompt(dna_after)
@@ -196,6 +203,76 @@ def _remove_hedging(text: str) -> str:
     return result
 
 
+def _apply_task_scaffold(text: str, dna: object) -> str:
+    """Append task-specific structural cues based on detected task type.
+
+    Only fires when the prompt is short (<30 words) AND missing critical
+    context for the detected task type. Adds fill-in-the-blank lines so
+    the user knows what to add — not generic advice, but structured slots.
+
+    Slot design informed by:
+    - fabric patterns (danielmiessler/fabric, 40k stars): IDENTITY/STEPS/OUTPUT
+    - steipete/agent-rules (5.6k stars): bug-fix, analyze-issue, pr-review
+    - awesome-cursorrules (38k stars): framework-specific conventions
+    """
+    task = getattr(dna, "task_type", "other")
+    word_count = getattr(dna, "word_count", 0)
+
+    # Only scaffold short prompts — long prompts already have context
+    if word_count > 30:
+        return text
+
+    missing: list[str] = []
+
+    if task == "debug":
+        # steipete/agent-rules: bug-fix requires reproduce + expected vs actual
+        if not getattr(dna, "has_error_messages", False):
+            missing.append("Error: <paste the error message or stack trace>")
+        if not getattr(dna, "has_file_references", False):
+            missing.append("File: <which file and function>")
+        # Expected vs actual is the most diagnostic slot (from bug-fix.mdc)
+        missing.append("Expected: <what should happen vs what actually happens>")
+
+    elif task == "implement":
+        if not getattr(dna, "has_io_spec", False):
+            missing.append("Input/Output: <what it takes and returns>")
+        if not getattr(dna, "has_constraints", False):
+            missing.append("Constraints: <what NOT to change>")
+        if not getattr(dna, "has_edge_cases", False):
+            missing.append("Edge cases: <empty input, null, zero, etc.>")
+
+    elif task == "refactor":
+        if not getattr(dna, "has_file_references", False):
+            missing.append("Scope: <which files/modules to touch>")
+        if not getattr(dna, "has_constraints", False):
+            missing.append("Preserve: <what must NOT change (API, tests, etc.)>")
+        # fabric/awesome-cursorrules: refactors benefit from target pattern
+        missing.append("Goal: <readability, performance, or pattern to apply>")
+
+    elif task == "test":
+        if not getattr(dna, "has_file_references", False):
+            missing.append("Target: <function or module to test>")
+        if not getattr(dna, "has_edge_cases", False):
+            missing.append("Edge cases: <empty, null, boundary values>")
+        if not getattr(dna, "has_io_spec", False):
+            missing.append("Expected: <what the correct behavior should be>")
+
+    elif task == "review":
+        # fabric review_code: 6 named axes instead of generic "focus"
+        if not getattr(dna, "has_constraints", False):
+            missing.append(
+                "Review axes: <correctness, security, performance, readability, error handling>"
+            )
+        if not getattr(dna, "has_file_references", False):
+            missing.append("Scope: <which files or PR to review>")
+
+    if not missing:
+        return text
+
+    scaffold = "\n".join(missing)
+    return f"{text.rstrip()}\n\n{scaffold}"
+
+
 def _generate_manual_suggestions(dna: object) -> list[str]:
     """Generate suggestions for improvements that require human input."""
     suggestions: list[str] = []

{reprompt_cli-2.3.0 → reprompt_cli-2.4.0}/src/reprompt/core/suggestions.py

@@ -28,6 +28,7 @@ SUGGESTIONS: dict[str, str] = {
     "explain": "reprompt rewrite (auto-improve) · reprompt build (construct from parts)",
     "rewrite": "reprompt compress (reduce tokens) · reprompt score (verify improvement)",
     "projects": "reprompt sessions --detail <id> (deep-dive) · reprompt insights (patterns)",
+    "patterns": "reprompt rewrite (auto-improve gaps) · reprompt insights (full analysis)",
 }
 
 

reprompt_cli-2.4.0/src/reprompt/output/patterns_terminal.py

@@ -0,0 +1,76 @@
+"""Rich terminal rendering for personal prompt patterns."""
+
+from __future__ import annotations
+
+from io import StringIO
+
+from rich.console import Console
+from rich.table import Table
+
+from reprompt.core.patterns import PatternsReport
+
+
+def render_patterns(report: PatternsReport) -> str:
+    """Render a PatternsReport as formatted terminal output."""
+    console = Console(record=True, width=100, file=StringIO())
+
+    if report.total_analyzed == 0:
+        console.print(
+            "\n  [dim]No scored prompts found. Run [bold]reprompt scan[/bold] first.[/dim]\n"
+        )
+        return console.export_text()
+
+    console.print()
+
+    # Header
+    analyzed = report.total_analyzed
+    console.print(
+        f"  [bold]Personal Prompt Patterns[/bold]  [dim]({analyzed} prompts analyzed)[/dim]"
+    )
+    console.print()
+
+    # Task distribution bar
+    total = report.total_analyzed
+    for task, count in sorted(report.task_distribution.items(), key=lambda x: x[1], reverse=True):
+        pct = count / total * 100
+        bar_len = int(pct / 2)
+        bar = "█" * bar_len
+        console.print(f"  [dim]{task:<12}[/dim] [cyan]{bar}[/cyan] {count} ({pct:.0f}%)")
+
+    console.print()
+
+    # Per-task patterns
+    for pattern in report.patterns:
+        if not pattern.gaps:
+            continue
+
+        tt = pattern.task_type
+        cnt = pattern.count
+        avg = pattern.avg_score
+        console.print(f"  [bold]{tt}[/bold] prompts  [dim]({cnt} total, avg score {avg})[/dim]")
+
+        for gap in pattern.gaps:
+            pct = int(gap.missing_rate * 100)
+            color = "red" if gap.impact == "high" else "yellow" if gap.impact == "medium" else "dim"
+            console.print(
+                f"    [{color}]{pct}% missing {gap.label}[/{color}]  [dim]→ {gap.suggestion}[/dim]"
+            )
+
+        console.print()
+
+    # Top gaps summary
+    if report.top_gaps:
+        console.print("  [bold]Your most common gaps[/bold]")
+        table = Table(show_header=True, header_style="dim", box=None, padding=(0, 2))
+        table.add_column("Gap", style="bold")
+        table.add_column("Missing", justify="right")
+        table.add_column("Fix", style="dim")
+
+        for gap in report.top_gaps:
+            pct = f"{int(gap.missing_rate * 100)}%"
+            table.add_row(gap.label, pct, gap.suggestion)
+
+        console.print(table)
+        console.print()
+
+    return console.export_text()

reprompt_cli-2.4.0/tests/test_patterns.py

@@ -0,0 +1,166 @@
+"""Tests for personal prompt patterns analysis."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from reprompt.core.patterns import analyze_patterns
+from reprompt.storage.db import PromptDB
+
+
+@pytest.fixture
+def db(tmp_path: Path) -> PromptDB:
+    return PromptDB(tmp_path / "test.db")
+
+
+def _store_feature(db: PromptDB, text: str, task_type: str, **features: bool | float) -> None:
+    """Store a prompt + features for pattern analysis."""
+    import hashlib
+
+    h = hashlib.sha256(text.encode()).hexdigest()
+
+    conn = db._conn()
+    try:
+        conn.execute(
+            "INSERT OR IGNORE INTO prompts (hash, text, source, session_id) VALUES (?, ?, ?, ?)",
+            (h, text, "test", "s1"),
+        )
+        feature_dict = {
+            "has_error_messages": False,
+            "has_file_references": False,
+            "has_code_blocks": False,
+            "has_constraints": False,
+            "has_io_spec": False,
+            "has_edge_cases": False,
+            "has_examples": False,
+            "has_output_format": False,
+            "has_role_definition": False,
+            "has_step_by_step": False,
+            **features,
+        }
+        conn.execute(
+            "INSERT OR REPLACE INTO prompt_features "
+            "(prompt_hash, features_json, overall_score, task_type, computed_at) "
+            "VALUES (?, ?, ?, ?, datetime('now'))",
+            (h, json.dumps(feature_dict), features.get("overall_score", 40.0), task_type),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+
+class TestAnalyzePatterns:
+    def test_empty_db(self, db: PromptDB) -> None:
+        report = analyze_patterns(db)
+        assert report.total_analyzed == 0
+        assert report.patterns == []
+        assert report.top_gaps == []
+
+    def test_single_task_type(self, db: PromptDB) -> None:
+        for i in range(5):
+            _store_feature(db, f"fix bug {i}", "debug")
+        report = analyze_patterns(db)
+        assert report.total_analyzed == 5
+        assert "debug" in report.task_distribution
+
+    def test_detects_missing_error_messages(self, db: PromptDB) -> None:
+        # 4/5 debug prompts missing error messages
+        for i in range(4):
+            _store_feature(db, f"fix bug {i}", "debug", has_error_messages=False)
+        _store_feature(db, "fix bug with error", "debug", has_error_messages=True)
+
+        report = analyze_patterns(db)
+        debug_pattern = next((p for p in report.patterns if p.task_type == "debug"), None)
+        assert debug_pattern is not None
+        error_gap = next((g for g in debug_pattern.gaps if g.feature == "has_error_messages"), None)
+        assert error_gap is not None
+        assert error_gap.missing_rate == 0.8  # 4/5
+
+    def test_no_gap_when_feature_present(self, db: PromptDB) -> None:
+        # All debug prompts have error messages
+        for i in range(5):
+            _store_feature(db, f"fix bug {i}", "debug", has_error_messages=True)
+
+        report = analyze_patterns(db)
+        debug_pattern = next((p for p in report.patterns if p.task_type == "debug"), None)
+        if debug_pattern:
+            error_gap = next(
+                (g for g in debug_pattern.gaps if g.feature == "has_error_messages"), None
+            )
+            assert error_gap is None  # no gap reported
+
+    def test_multiple_task_types(self, db: PromptDB) -> None:
+        for i in range(5):
+            _store_feature(db, f"fix bug {i}", "debug")
+        for i in range(3):
+            _store_feature(db, f"implement feature {i}", "implement")
+
+        report = analyze_patterns(db)
+        assert len(report.task_distribution) >= 2
+
+    def test_top_gaps_deduplication(self, db: PromptDB) -> None:
+        # file_references missing in both debug and implement
+        for i in range(5):
+            _store_feature(db, f"fix bug {i}", "debug", has_file_references=False)
+        for i in range(5):
+            _store_feature(db, f"implement feat {i}", "implement", has_file_references=False)
+
+        report = analyze_patterns(db)
+        file_gaps = [g for g in report.top_gaps if g.feature == "has_file_references"]
+        assert len(file_gaps) == 1  # deduplicated
+
+    def test_skips_small_task_groups(self, db: PromptDB) -> None:
+        # Only 2 prompts — not enough for meaningful patterns
+        _store_feature(db, "review code 1", "review")
+        _store_feature(db, "review code 2", "review")
+
+        report = analyze_patterns(db)
+        review_pattern = next((p for p in report.patterns if p.task_type == "review"), None)
+        assert review_pattern is None  # skipped, need >= 3
+
+    def test_json_serializable(self, db: PromptDB) -> None:
+        for i in range(5):
+            _store_feature(db, f"fix bug {i}", "debug")
+
+        from dataclasses import asdict
+
+        report = analyze_patterns(db)
+        data = asdict(report)
+        json.dumps(data)  # should not raise
+
+    def test_gap_has_suggestion(self, db: PromptDB) -> None:
+        for i in range(5):
+            _store_feature(db, f"fix bug {i}", "debug", has_error_messages=False)
+
+        report = analyze_patterns(db)
+        debug_pattern = next((p for p in report.patterns if p.task_type == "debug"), None)
+        assert debug_pattern is not None
+        for gap in debug_pattern.gaps:
+            assert gap.suggestion  # non-empty
+            assert gap.impact in ("high", "medium", "low")
+
+
+class TestPatternsCLI:
+    def test_patterns_command_exists(self) -> None:
+        from typer.testing import CliRunner
+
+        from reprompt.cli import app
+
+        runner = CliRunner()
+        result = runner.invoke(app, ["patterns", "--help"])
+        assert result.exit_code == 0
+        assert "personal" in result.output.lower() or "weakness" in result.output.lower()
+
+    def test_patterns_json_output(self) -> None:
+        from typer.testing import CliRunner
+
+        from reprompt.cli import app
+
+        runner = CliRunner()
+        result = runner.invoke(app, ["patterns", "--json"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert "total_analyzed" in data

{reprompt_cli-2.3.0 → reprompt_cli-2.4.0}/tests/test_rewrite.py

@@ -110,6 +110,55 @@ class TestRewritePrompt:
         result = rewrite_prompt("x")
         assert isinstance(result, RewriteResult)
 
+    # -- Layer 5: Task-specific scaffold tests --
+
+    def test_debug_scaffold_adds_error_slot(self):
+        result = rewrite_prompt("fix the auth bug")
+        # Short debug prompt should get error/file/code scaffold
+        has_scaffold = any("debug" in c.lower() or "structure" in c.lower() for c in result.changes)
+        suggestions_text = " ".join(result.manual_suggestions).lower()
+        has_error_slot = "Error:" in result.rewritten or "error" in suggestions_text
+        assert has_scaffold or has_error_slot
+
+    def test_implement_scaffold_adds_io_spec(self):
+        result = rewrite_prompt("implement user login")
+        # Should suggest I/O spec or constraints
+        all_text = result.rewritten + " ".join(result.manual_suggestions)
+        has_io = "Input/Output:" in all_text or "input/output" in all_text.lower()
+        has_constraints = "Constraints:" in all_text or "constraint" in all_text.lower()
+        assert has_io or has_constraints
+
+    def test_refactor_scaffold_adds_scope(self):
+        result = rewrite_prompt("refactor the auth module")
+        all_text = result.rewritten + " ".join(result.manual_suggestions)
+        has_scope = "Scope:" in all_text or "file" in all_text.lower()
+        assert has_scope
+
+    def test_test_scaffold_adds_target(self):
+        result = rewrite_prompt("write tests for login")
+        all_text = result.rewritten + " ".join(result.manual_suggestions)
+        lower_text = all_text.lower()
+        has_target = "Target:" in all_text or "function" in lower_text or "edge" in lower_text
+        assert has_target
+
+    def test_long_prompt_no_scaffold(self):
+        # Long prompts (>30 words) should NOT get scaffold
+        long_prompt = (
+            "Fix the authentication bug in src/auth/middleware.ts where the JWT token "
+            "expiration check fails for tokens issued before the timezone migration. "
+            "The error is TypeError: Cannot read property 'exp' of undefined at line 42. "
+            "Do not modify the refresh token logic."
+        )
+        result = rewrite_prompt(long_prompt)
+        has_scaffold = any("structure" in c.lower() for c in result.changes)
+        assert not has_scaffold
+
+    def test_scaffold_not_duplicated(self):
+        # If prompt already has error message, don't add Error: slot
+        result = rewrite_prompt("fix the TypeError in auth.ts")
+        # Should not scaffold Error: because error message is present
+        assert result.rewritten.count("Error:") <= 1
+
 
 class TestRewriteCLI:
     def test_rewrite_command_exists(self):

{reprompt_cli-2.3.0 → reprompt_cli-2.4.0}/tests/test_suggestions.py

@@ -23,6 +23,7 @@ class TestGetSuggestion:
             "build",
             "check",
             "explain",
+            "patterns",
         }
         assert set(SUGGESTIONS.keys()) == expected
 

{reprompt_cli-2.3.0 → reprompt_cli-2.4.0}/uv.lock

@@ -2210,7 +2210,7 @@ wheels = [
 
 [[package]]
 name = "reprompt-cli"
-version = "2.3.0"
+version = "2.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "pydantic-settings" },