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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reprompt-cli
-Version: 1.9.0
+Version: 1.9.1
 Summary: Discover, analyze, and optimize your prompts from AI coding sessions
 Project-URL: Homepage, https://github.com/reprompt-dev/reprompt
 Project-URL: Repository, https://github.com/reprompt-dev/reprompt

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

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

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

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

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

@@ -820,13 +820,19 @@ def lint(
     import json as json_mod
 
     from reprompt.config import Settings
-    from reprompt.core.lint import format_lint_results, lint_prompts
+    from reprompt.core.lint import format_lint_results, lint_prompts, load_lint_config
     from reprompt.core.pipeline import get_adapters
     from reprompt.storage.db import PromptDB
 
     settings = Settings()
     db = PromptDB(settings.db_path)
 
+    # Load lint config from .reprompt.toml / pyproject.toml
+    lint_config = load_lint_config()
+
+    # CLI flags override config file
+    effective_threshold = score_threshold if score_threshold > 0 else lint_config.score_threshold
+
     # Collect prompts from DB (already scanned)
     rows = db.get_all_prompts()
     texts = [r["text"] for r in rows]
@@ -858,11 +864,11 @@ def lint(
         console.print("No prompts found. Run [bold]reprompt scan[/bold] first.")
         raise typer.Exit(0)
 
-    violations = lint_prompts(texts)
+    violations = lint_prompts(texts, config=lint_config)
 
     # Score threshold mode (CI integration)
     score_data = None
-    if score_threshold > 0:
+    if effective_threshold > 0:
         from reprompt.core.extractors import extract_features
         from reprompt.core.scorer import score_prompt
 
@@ -875,8 +881,8 @@ def lint(
             "avg_score": round(avg_score, 1),
             "min_score": min(scores) if scores else 0,
             "max_score": max(scores) if scores else 0,
-            "threshold": score_threshold,
-            "pass": avg_score >= score_threshold,
+            "threshold": effective_threshold,
+            "pass": avg_score >= effective_threshold,
         }
 
     if json_output:
@@ -905,7 +911,7 @@ def lint(
             console.print(
                 f"\n  Score: avg {score_data['avg_score']}/100"
                 f" (min {score_data['min_score']}, max {score_data['max_score']})"
-                f" — threshold {score_threshold} → {status}"
+                f" — threshold {effective_threshold} → {status}"
             )
 
     if copy:

reprompt_cli-1.9.1/src/reprompt/core/lint.py

@@ -0,0 +1,242 @@
+"""Prompt quality linting rules.
+
+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)
+2. .reprompt.toml in CWD or parents
+3. [tool.reprompt.lint] in pyproject.toml
+4. Built-in defaults
+"""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomllib
+    except ModuleNotFoundError:  # Python 3.10
+        import tomli as tomllib  # type: ignore[no-redefine]
+
+
+@dataclass
+class LintViolation:
+    """A single lint rule violation."""
+
+    rule: str
+    severity: str  # "error" | "warning"
+    message: str
+    prompt_text: str
+
+
+@dataclass
+class LintConfig:
+    """Configuration for lint rules. Loaded from .reprompt.toml or pyproject.toml."""
+
+    # Rule thresholds (0 = disabled)
+    min_length: int = 20
+    short_prompt: int = 40
+
+    # Boolean rules (False = disabled)
+    vague_prompt: bool = True
+    debug_needs_reference: bool = True
+
+    # File extensions for debug-needs-reference
+    file_extensions: list[str] = field(
+        default_factory=lambda: [".py", ".ts", ".js", ".go", ".rs", ".java", ".rb", ".cpp", ".c"]
+    )
+
+    # CI score threshold (0 = disabled, set via --score-threshold or config)
+    score_threshold: int = 0
+
+
+# --- Default config ---
+DEFAULT_CONFIG = LintConfig()
+
+VAGUE_STARTERS = frozenset(
+    {"fix it", "fix this", "do it", "help me", "change it", "update it", "make it work"}
+)
+
+
+def load_lint_config(start_dir: Path | None = None) -> LintConfig:
+    """Load lint config from .reprompt.toml or pyproject.toml, walking up from start_dir.
+
+    Returns DEFAULT_CONFIG if no config file found.
+    """
+    if start_dir is None:
+        start_dir = Path.cwd()
+
+    # Walk up to find config files
+    current = start_dir.resolve()
+    for _ in range(20):  # safety limit
+        # Check .reprompt.toml first (project-specific)
+        reprompt_toml = current / ".reprompt.toml"
+        if reprompt_toml.is_file():
+            return _parse_reprompt_toml(reprompt_toml)
+
+        # Check pyproject.toml
+        pyproject = current / "pyproject.toml"
+        if pyproject.is_file():
+            config = _parse_pyproject_toml(pyproject)
+            if config is not None:
+                return config
+
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+
+    return LintConfig()
+
+
+def _parse_reprompt_toml(path: Path) -> LintConfig:
+    """Parse a .reprompt.toml file."""
+    try:
+        with open(path, "rb") as f:
+            data = tomllib.load(f)
+        return _build_config(data.get("lint", {}))
+    except Exception:
+        return LintConfig()
+
+
+def _parse_pyproject_toml(path: Path) -> LintConfig | None:
+    """Parse [tool.reprompt.lint] from pyproject.toml. Returns None if section missing."""
+    try:
+        with open(path, "rb") as f:
+            data = tomllib.load(f)
+        lint_section = data.get("tool", {}).get("reprompt", {}).get("lint")
+        if lint_section is None:
+            return None
+        return _build_config(lint_section)
+    except Exception:
+        return None
+
+
+def _build_config(lint_data: dict) -> LintConfig:
+    """Build LintConfig from a parsed TOML dict."""
+    config = LintConfig()
+
+    # Top-level lint settings
+    if "score-threshold" in lint_data:
+        config.score_threshold = int(lint_data["score-threshold"])
+
+    # Rule settings
+    rules = lint_data.get("rules", {})
+
+    # min-length: int threshold or false
+    if "min-length" in rules:
+        val = rules["min-length"]
+        config.min_length = int(val) if val else 0
+
+    # short-prompt: int threshold or false
+    if "short-prompt" in rules:
+        val = rules["short-prompt"]
+        config.short_prompt = int(val) if val else 0
+
+    # vague-prompt: bool
+    if "vague-prompt" in rules:
+        config.vague_prompt = bool(rules["vague-prompt"])
+
+    # debug-needs-reference: bool
+    if "debug-needs-reference" in rules:
+        config.debug_needs_reference = bool(rules["debug-needs-reference"])
+
+    # file-extensions: list
+    if "file-extensions" in rules:
+        config.file_extensions = list(rules["file-extensions"])
+
+    return config
+
+
+def lint_prompt(text: str, config: LintConfig | None = None) -> list[LintViolation]:
+    """Lint a single prompt against quality rules."""
+    if config is None:
+        config = DEFAULT_CONFIG
+
+    violations: list[LintViolation] = []
+    stripped = text.strip().lower()
+
+    # Rule 1: Too short
+    if config.min_length > 0 and len(stripped) < config.min_length:
+        violations.append(
+            LintViolation(
+                rule="min-length",
+                severity="error",
+                message=f"Prompt is too short ({len(stripped)} chars, minimum {config.min_length})",
+                prompt_text=text,
+            )
+        )
+    elif config.short_prompt > 0 and len(stripped) < config.short_prompt:
+        violations.append(
+            LintViolation(
+                rule="short-prompt",
+                severity="warning",
+                message=(f"Prompt is short ({len(stripped)} chars) — consider adding context"),
+                prompt_text=text,
+            )
+        )
+
+    # Rule 2: Vague starter
+    if config.vague_prompt and stripped in VAGUE_STARTERS:
+        violations.append(
+            LintViolation(
+                rule="vague-prompt",
+                severity="error",
+                message="Prompt is too vague — specify what to fix/change and where",
+                prompt_text=text,
+            )
+        )
+
+    # Rule 3: No file/function reference in debug prompts
+    if config.debug_needs_reference:
+        debug_words = {"fix", "debug", "bug", "error", "broken", "failing", "crash"}
+        has_debug_intent = any(w in stripped for w in debug_words)
+        indicators = list(config.file_extensions) + ["()", "line ", "file "]
+        has_reference = any(indicator in text for indicator in indicators)
+        min_len = config.min_length if config.min_length > 0 else 20
+        if has_debug_intent and not has_reference and len(stripped) >= min_len:
+            violations.append(
+                LintViolation(
+                    rule="debug-needs-reference",
+                    severity="warning",
+                    message="Debug prompt lacks file/function reference — add specifics",
+                    prompt_text=text,
+                )
+            )
+
+    return violations
+
+
+def lint_prompts(texts: list[str], config: LintConfig | None = None) -> list[LintViolation]:
+    """Lint multiple prompts and return all violations."""
+    violations: list[LintViolation] = []
+    for text in texts:
+        violations.extend(lint_prompt(text, config))
+    return violations
+
+
+def format_lint_results(violations: list[LintViolation], total_prompts: int) -> str:
+    """Format lint results for terminal/CI output."""
+    if not violations:
+        return f"✓ {total_prompts} prompts checked, no issues found"
+
+    errors = [v for v in violations if v.severity == "error"]
+    warnings = [v for v in violations if v.severity == "warning"]
+
+    lines: list[str] = []
+    lines.append(f"Checked {total_prompts} prompts\n")
+
+    for v in violations:
+        prefix = "✗" if v.severity == "error" 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)")
+    return "\n".join(lines)

reprompt_cli-1.9.1/tests/test_lint.py

@@ -0,0 +1,237 @@
+"""Tests for prompt linting rules and configuration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from reprompt.core.lint import (
+    LintConfig,
+    LintViolation,
+    format_lint_results,
+    lint_prompt,
+    lint_prompts,
+    load_lint_config,
+)
+
+
+class TestLintPrompt:
+    def test_good_prompt_no_violations(self):
+        violations = lint_prompt("fix the authentication bug in auth.py — login returns 401")
+        assert violations == []
+
+    def test_too_short_error(self):
+        violations = lint_prompt("fix bug")
+        assert len(violations) == 1
+        assert violations[0].rule == "min-length"
+        assert violations[0].severity == "error"
+
+    def test_short_warning(self):
+        violations = lint_prompt("fix the auth bug please")
+        rules = [v.rule for v in violations]
+        assert "short-prompt" in rules
+
+    def test_vague_prompt_error(self):
+        violations = lint_prompt("fix it")
+        rules = [v.rule for v in violations]
+        assert "vague-prompt" in rules
+
+    def test_debug_without_reference(self):
+        violations = lint_prompt("fix the authentication error in the login flow")
+        rules = [v.rule for v in violations]
+        assert "debug-needs-reference" in rules
+
+    def test_debug_with_reference_ok(self):
+        violations = lint_prompt("fix the authentication error in auth.py login flow")
+        rules = [v.rule for v in violations]
+        assert "debug-needs-reference" not in rules
+
+    def test_non_debug_no_reference_warning(self):
+        """Non-debug prompts don't need file references."""
+        violations = lint_prompt("add pagination to the search results page")
+        rules = [v.rule for v in violations]
+        assert "debug-needs-reference" not in rules
+
+
+class TestLintPrompts:
+    def test_multiple_prompts(self):
+        violations = lint_prompts(
+            [
+                "fix the authentication bug in auth.py — login returns 401",
+                "fix it",
+                "add pagination to search results with cursor-based navigation",
+            ]
+        )
+        assert len(violations) >= 1  # "fix it" triggers violations
+
+    def test_empty_list(self):
+        assert lint_prompts([]) == []
+
+
+class TestFormatResults:
+    def test_no_violations(self):
+        result = format_lint_results([], 10)
+        assert "no issues found" in result
+        assert "10" in result
+
+    def test_with_violations(self):
+        violations = lint_prompt("fix it")
+        result = format_lint_results(violations, 5)
+        assert "error" in result
+        assert "fix it" in result
+
+    def test_truncates_long_prompts(self):
+        long_prompt = "x" * 100
+        v = LintViolation(rule="test", severity="error", message="test", prompt_text=long_prompt)
+        result = format_lint_results([v], 1)
+        assert "..." in result
+
+
+# -- LintConfig tests --
+
+
+class TestLintConfig:
+    def test_default_config(self):
+        config = LintConfig()
+        assert config.min_length == 20
+        assert config.short_prompt == 40
+        assert config.vague_prompt is True
+        assert config.debug_needs_reference is True
+        assert config.score_threshold == 0
+        assert ".py" in config.file_extensions
+
+    def test_custom_min_length(self):
+        config = LintConfig(min_length=10)
+        # "fix bug" is 7 chars — under 10
+        violations = lint_prompt("fix bug", config=config)
+        assert any(v.rule == "min-length" for v in violations)
+        # "very short" is 10 chars — at threshold, should pass
+        violations = lint_prompt("0123456789", config=config)
+        assert not any(v.rule == "min-length" for v in violations)
+
+    def test_disabled_min_length(self):
+        config = LintConfig(min_length=0)
+        violations = lint_prompt("hi", config=config)
+        assert not any(v.rule == "min-length" for v in violations)
+
+    def test_disabled_short_prompt(self):
+        config = LintConfig(min_length=0, short_prompt=0)
+        violations = lint_prompt("fix the auth bug please", config=config)
+        assert not any(v.rule == "short-prompt" for v in violations)
+
+    def test_disabled_vague_prompt(self):
+        config = LintConfig(min_length=0, vague_prompt=False)
+        violations = lint_prompt("fix it", config=config)
+        assert not any(v.rule == "vague-prompt" for v in violations)
+
+    def test_disabled_debug_needs_reference(self):
+        config = LintConfig(debug_needs_reference=False)
+        violations = lint_prompt("fix the authentication error in the login flow", config=config)
+        assert not any(v.rule == "debug-needs-reference" for v in violations)
+
+    def test_custom_file_extensions(self):
+        config = LintConfig(file_extensions=[".py", ".ts"])
+        # .go is not in extensions, so no reference detected
+        violations = lint_prompt("fix the authentication error in auth.go flow", config=config)
+        assert any(v.rule == "debug-needs-reference" for v in violations)
+        # .py IS in extensions
+        violations = lint_prompt("fix the authentication error in auth.py flow", config=config)
+        assert not any(v.rule == "debug-needs-reference" for v in violations)
+
+    def test_custom_short_threshold(self):
+        config = LintConfig(short_prompt=60)
+        violations = lint_prompt("add pagination to the search results page")
+        rules_default = [v.rule for v in violations]
+        assert "short-prompt" not in rules_default  # 42 chars, under 40 default = no warning
+
+        violations = lint_prompt("add pagination to the search results page", config=config)
+        rules_custom = [v.rule for v in violations]
+        assert "short-prompt" in rules_custom  # 42 chars, under 60 threshold
+
+    def test_lint_prompts_with_config(self):
+        config = LintConfig(min_length=0, short_prompt=0, vague_prompt=False)
+        violations = lint_prompts(["fix it", "hi", "ok"], config=config)
+        # With all rules disabled, everything passes
+        assert violations == []
+
+
+# -- Config file loading tests --
+
+
+class TestLoadLintConfig:
+    def test_no_config_returns_defaults(self, tmp_path: Path):
+        config = load_lint_config(start_dir=tmp_path)
+        assert config.min_length == 20
+        assert config.short_prompt == 40
+        assert config.score_threshold == 0
+
+    def test_reprompt_toml(self, tmp_path: Path):
+        toml_file = tmp_path / ".reprompt.toml"
+        toml_file.write_text(
+            "[lint]\nscore-threshold = 60\n\n[lint.rules]\nmin-length = 10\nvague-prompt = false\n"
+        )
+        config = load_lint_config(start_dir=tmp_path)
+        assert config.score_threshold == 60
+        assert config.min_length == 10
+        assert config.vague_prompt is False
+        # Unset rules keep defaults
+        assert config.short_prompt == 40
+        assert config.debug_needs_reference is True
+
+    def test_pyproject_toml(self, tmp_path: Path):
+        pyproject = tmp_path / "pyproject.toml"
+        pyproject.write_text(
+            "[tool.reprompt.lint]\n"
+            "score-threshold = 45\n\n"
+            "[tool.reprompt.lint.rules]\n"
+            "short-prompt = 0\n"
+            "debug-needs-reference = false\n"
+        )
+        config = load_lint_config(start_dir=tmp_path)
+        assert config.score_threshold == 45
+        assert config.short_prompt == 0
+        assert config.debug_needs_reference is False
+
+    def test_reprompt_toml_takes_precedence(self, tmp_path: Path):
+        """When both exist, .reprompt.toml wins."""
+        (tmp_path / ".reprompt.toml").write_text("[lint]\nscore-threshold = 70\n")
+        (tmp_path / "pyproject.toml").write_text("[tool.reprompt.lint]\nscore-threshold = 30\n")
+        config = load_lint_config(start_dir=tmp_path)
+        assert config.score_threshold == 70
+
+    def test_walks_up_directories(self, tmp_path: Path):
+        """Config in parent dir should be found."""
+        (tmp_path / ".reprompt.toml").write_text("[lint]\nscore-threshold = 55\n")
+        subdir = tmp_path / "src" / "module"
+        subdir.mkdir(parents=True)
+        config = load_lint_config(start_dir=subdir)
+        assert config.score_threshold == 55
+
+    def test_pyproject_without_reprompt_section(self, tmp_path: Path):
+        """pyproject.toml without [tool.reprompt] should return defaults."""
+        (tmp_path / "pyproject.toml").write_text("[project]\nname = 'foo'\n")
+        config = load_lint_config(start_dir=tmp_path)
+        assert config.min_length == 20  # default
+
+    def test_invalid_toml_returns_defaults(self, tmp_path: Path):
+        (tmp_path / ".reprompt.toml").write_text("this is not valid toml {{{{")
+        config = load_lint_config(start_dir=tmp_path)
+        assert config.min_length == 20  # graceful fallback
+
+    def test_file_extensions_config(self, tmp_path: Path):
+        (tmp_path / ".reprompt.toml").write_text(
+            '[lint.rules]\nfile-extensions = [".py", ".ts", ".vue"]\n'
+        )
+        config = load_lint_config(start_dir=tmp_path)
+        assert config.file_extensions == [".py", ".ts", ".vue"]
+
+    def test_disable_all_rules(self, tmp_path: Path):
+        (tmp_path / ".reprompt.toml").write_text(
+            "[lint.rules]\n"
+            "min-length = 0\n"
+            "short-prompt = 0\n"
+            "vague-prompt = false\n"
+            "debug-needs-reference = false\n"
+        )
+        config = load_lint_config(start_dir=tmp_path)
+        violations = lint_prompts(["fix it", "hi", "ok"], config=config)
+        assert violations == []

{reprompt_cli-1.9.0 → reprompt_cli-1.9.1}/uv.lock

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

reprompt_cli-1.9.0/src/reprompt/core/lint.py

@@ -1,112 +0,0 @@
-"""Prompt quality linting rules.
-
-Checks prompts against configurable quality rules and returns violations.
-Designed for CI integration — each rule produces a severity + message.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-
-@dataclass
-class LintViolation:
-    """A single lint rule violation."""
-
-    rule: str
-    severity: str  # "error" | "warning"
-    message: str
-    prompt_text: str
-
-
-# --- Default thresholds ---
-MIN_LENGTH = 20
-SHORT_WARNING_LENGTH = 40
-VAGUE_STARTERS = frozenset(
-    {"fix it", "fix this", "do it", "help me", "change it", "update it", "make it work"}
-)
-
-
-def lint_prompt(text: str) -> list[LintViolation]:
-    """Lint a single prompt against quality rules."""
-    violations: list[LintViolation] = []
-    stripped = text.strip().lower()
-
-    # Rule 1: Too short
-    if len(stripped) < MIN_LENGTH:
-        violations.append(
-            LintViolation(
-                rule="min-length",
-                severity="error",
-                message=f"Prompt is too short ({len(stripped)} chars, minimum {MIN_LENGTH})",
-                prompt_text=text,
-            )
-        )
-    elif len(stripped) < SHORT_WARNING_LENGTH:
-        violations.append(
-            LintViolation(
-                rule="short-prompt",
-                severity="warning",
-                message=f"Prompt is short ({len(stripped)} chars) — consider adding context",
-                prompt_text=text,
-            )
-        )
-
-    # Rule 2: Vague starter
-    if stripped in VAGUE_STARTERS:
-        violations.append(
-            LintViolation(
-                rule="vague-prompt",
-                severity="error",
-                message="Prompt is too vague — specify what to fix/change and where",
-                prompt_text=text,
-            )
-        )
-
-    # Rule 3: No file/function reference in debug prompts
-    debug_words = {"fix", "debug", "bug", "error", "broken", "failing", "crash"}
-    has_debug_intent = any(w in stripped for w in debug_words)
-    has_reference = any(
-        indicator in text
-        for indicator in (".py", ".ts", ".js", ".go", ".rs", "()", "line ", "file ")
-    )
-    if has_debug_intent and not has_reference and len(stripped) >= MIN_LENGTH:
-        violations.append(
-            LintViolation(
-                rule="debug-needs-reference",
-                severity="warning",
-                message="Debug prompt lacks file/function reference — add specifics",
-                prompt_text=text,
-            )
-        )
-
-    return violations
-
-
-def lint_prompts(texts: list[str]) -> list[LintViolation]:
-    """Lint multiple prompts and return all violations."""
-    violations: list[LintViolation] = []
-    for text in texts:
-        violations.extend(lint_prompt(text))
-    return violations
-
-
-def format_lint_results(violations: list[LintViolation], total_prompts: int) -> str:
-    """Format lint results for terminal/CI output."""
-    if not violations:
-        return f"✓ {total_prompts} prompts checked, no issues found"
-
-    errors = [v for v in violations if v.severity == "error"]
-    warnings = [v for v in violations if v.severity == "warning"]
-
-    lines: list[str] = []
-    lines.append(f"Checked {total_prompts} prompts\n")
-
-    for v in violations:
-        prefix = "✗" if v.severity == "error" 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)")
-    return "\n".join(lines)