python-code-quality 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

py_cq/cli.py

@@ -16,6 +16,7 @@ import json
 import logging
 import tomllib
 from enum import Enum
+from importlib import import_module
 from pathlib import Path
 
 import typer
@@ -26,6 +27,7 @@ from rich.table import Table
 from py_cq.config import load_user_config
 from py_cq.execution_engine import _cache as tool_cache
 from py_cq.execution_engine import run_tools
+from py_cq.language_detector import detect_language
 from py_cq.localtypes import CombinedToolResults, ToolConfig
 from py_cq.metric_aggregator import aggregate_metrics
 from py_cq.tool_registry import tool_registry
@@ -43,7 +45,8 @@ app = typer.Typer(
         "  cq check .          # full table with all metrics (default)\n\n"
         "  cq check . -o llm   # top defect as markdown (primary LLM workflow)\n\n"
         "  cq check . -o score # numeric score only\n\n"
-        "  cq check . -o json  # full raw json of all tools"
+        "  cq check . -o json  # parsed metrics as json\n\n"
+        "  cq check . -o raw   # unprocessed tool output as json\n\n"
         "  cq config .         # show effective tool configuration"
     ),
 )
@@ -55,6 +58,7 @@ def _apply_user_config(base: dict[str, ToolConfig], user_cfg: dict) -> dict[str,
     Supports:
       - ``disable``: list of tool IDs to remove
       - ``thresholds.<tool_id>.warning`` / ``.error``: override per-tool thresholds
+      - ``tools.<tool_id>``: declare new tools (or override built-ins)
     """
     registry = {k: copy.copy(v) for k, v in base.items()}
     for tool_id in user_cfg.get("disable", []):
@@ -65,6 +69,24 @@ def _apply_user_config(base: dict[str, ToolConfig], user_cfg: dict) -> dict[str,
                 registry[tool_id].warning_threshold = float(thresholds["warning"])
             if "error" in thresholds:
                 registry[tool_id].error_threshold = float(thresholds["error"])
+    for tool_id, tool_data in user_cfg.get("tools", {}).items():
+        try:
+            parser_name = tool_data["parser"]
+            module = import_module(f"py_cq.parsers.{parser_name.lower()}")
+            parser_class = getattr(module, parser_name)
+            registry[tool_id] = ToolConfig(
+                name=tool_id,
+                command=tool_data["command"],
+                parser_class=parser_class,
+                order=tool_data["order"],
+                warning_threshold=tool_data["warning_threshold"],
+                error_threshold=tool_data["error_threshold"],
+                run_in_target_env=tool_data.get("run_in_target_env", False),
+                extra_deps=tool_data.get("extra_deps", []),
+                parser_config=tool_data.get("parser_config", {}),
+            )
+        except KeyError as e:
+            raise typer.BadParameter(f"[tool.cq.tools.{tool_id}] missing required field {e}")
     return registry
 
 
@@ -74,6 +96,7 @@ class OutputMode(str, Enum):
     SCORE = "score"
     JSON = "json"
     LLM = "llm"
+    RAW = "raw"
 
 
 @app.callback()
@@ -99,11 +122,27 @@ def check(
     workers: int = typer.Option(
         0, "--workers", help="Max parallel workers (default: one per tool, use 1 for sequential)"
     ),
+    language: str | None = typer.Option(
+        None, "--language", "-l", help="Override language detection (e.g. python, typescript, rust)"
+    ),
 ):
     """Feed the results from 11+ code quality tools to an LLM. Try: cq check . -o llm""" # --help
     path_obj = Path(path)
     if not path_obj.exists():
         raise typer.BadParameter(f"Path does not exist: {path}")
+
+    resolved_language = language or detect_language(path_obj)
+
+    if resolved_language is not None and resolved_language != "python":
+        console.print(
+            f"[yellow]{resolved_language.capitalize()} project detected. "
+            "Non-Python language support is not yet available.[/yellow]"
+        )
+        raise typer.Exit(0)
+
+    # Python path (or unknown — fall through to existing validation).
+    # Note: --language python still requires pyproject.toml; the flag selects
+    # the tool set, not the input validation rules.
     if path_obj.is_file():
         if path_obj.suffix != ".py":
             raise typer.BadParameter(f"File must be a Python file (.py): {path}")
@@ -111,24 +150,37 @@ def check(
         if not (path_obj / "pyproject.toml").exists():
             raise typer.BadParameter(f"Directory must contain pyproject.toml: {path}")
     log.setLevel(log_level)
-    effective_registry = _apply_user_config(tool_registry, load_user_config(path_obj))
+    user_cfg = load_user_config(path_obj)
+    context_lines: int = int(user_cfg.get("context_lines", 15))
+    effective_registry = _apply_user_config(tool_registry, user_cfg)
     if clear_cache:
         tool_cache.clear()
-    tool_results = run_tools(effective_registry.values(), path, workers)
-    for tr in tool_results:
-        log.debug(json.dumps(tr.to_dict(), indent=2))
+    tool_results = run_tools(effective_registry.values(), path, workers, early_exit=(output == OutputMode.LLM))
+    # for tr in tool_results:
+    #     log.debug(json.dumps(tr.to_dict(), indent=2))
     combined_metrics = aggregate_metrics(path=path, metrics=tool_results)
     if output == OutputMode.SCORE:
         console.print(combined_metrics.score)
     elif output == OutputMode.JSON:
-        console.print(json.dumps(combined_metrics.to_dict(), indent=2))
+        console.print(json.dumps([tr.to_dict() for tr in tool_results], indent=2))
+    elif output == OutputMode.RAW:
+        console.print(json.dumps([tr.raw.to_dict() for tr in tool_results], indent=2))
     elif output == OutputMode.LLM:
-        log.setLevel("CRITICAL")
+        # log.setLevel("CRITICAL")
         from py_cq.llm_formatter import format_for_llm
-        console.print(format_for_llm(effective_registry, combined_metrics))
+        console.print(format_for_llm(effective_registry, combined_metrics, context_lines=context_lines))
     else:
+        console.print(f"[bold green]{path_obj.resolve()}[/]")
         console.print(format_as_table(combined_metrics, effective_registry))
 
+    tool_by_name = {tc.name: tc for tc in effective_registry.values()}
+    if any(
+        min(tr.metrics.values()) < tool_by_name[tr.raw.tool_name].error_threshold
+        for tr in tool_results
+        if tr.metrics and tr.raw.tool_name in tool_by_name
+    ):
+        raise typer.Exit(code=1)
+
 
 @app.command()
 def config(
@@ -163,18 +215,19 @@ def config(
 
     table = Table()
     table.add_column("Tool", style="cyan")
-    table.add_column("Priority", justify="right")
+    table.add_column("Order", justify="right")
     table.add_column("Warning", justify="right")
     table.add_column("Error", justify="right")
     table.add_column("Status", justify="center")
 
-    for tool_id in sorted(tool_registry, key=lambda t: tool_registry[t].priority):
-        tc = effective_registry.get(tool_id, tool_registry[tool_id])
+    all_tool_ids = set(tool_registry) | set(effective_registry)
+    for tool_id in sorted(all_tool_ids, key=lambda t: (effective_registry.get(t) or tool_registry[t]).order):
+        tc = effective_registry.get(tool_id) or tool_registry[tool_id]
         is_disabled = tool_id in disabled_ids
         status = "[red]disabled[/red]" if is_disabled else "[green]enabled[/green]"
         table.add_row(
             tc.name,
-            str(tc.priority),
+            str(tc.order),
             f"{tc.warning_threshold:.2f}",
             f"{tc.error_threshold:.2f}",
             status,
@@ -200,7 +253,7 @@ def format_as_table(data: CombinedToolResults, registry: dict[str, ToolConfig]):
         >>> table = format_as_table(combined_results)
         >>> console.print(table)
     """
-    table = Table(title=f"[bold green]{data.path}[/]", width=80)
+    table = Table(width=80)
     table.add_column("Tool", justify="left", no_wrap=True)
     table.add_column("Time", justify="right", style="dim")
     table.add_column("Metric", justify="right", style="cyan", no_wrap=True)

py_cq/config/config.yaml

@@ -0,0 +1,88 @@
+python:
+
+  compile:
+    command: "{python} -m compileall -r 10 -j 8 \"{context_path}\" -x .*venv"
+    parser: "CompileParser"
+    order: 1
+    warning_threshold: 0.9999
+    error_threshold: 0.9999
+
+  ruff:
+    command: "{python} -m ruff check --output-format concise --no-cache \"{context_path}\""
+    parser: "RuffParser"
+    order: 2
+    warning_threshold: 0.9999
+    error_threshold: 0.9
+
+  ty:
+    command: "{python} -m ty check --output-format concise --color never \"{context_path}\""
+    parser: "TyParser"
+    order: 3
+    warning_threshold: 0.9999
+    error_threshold: 0.8
+    run_in_target_env: true
+    extra_deps:
+      - ty
+
+  bandit:
+    command: "{python} -m bandit -r \"{context_path}\" -f json -q -s B101 --severity-level medium --exclude \"{input_path_posix}/.venv,{input_path_posix}/tests\""
+    parser: "BanditParser"
+    order: 4
+    warning_threshold: 0.9999
+    error_threshold: 0.8
+
+  pytest:
+    command: "{python} -m pytest -v \"{context_path}\""
+    parser: "PytestParser"
+    order: 5
+    warning_threshold: 1.0
+    error_threshold: 1.0
+    run_in_target_env: true
+    extra_deps:
+      - pytest
+
+  coverage:
+    command: "{python} -m coverage run --omit=*/tests/*,*/test_*.py -m pytest \"{context_path}\" && {python} -m coverage report --omit=*/tests/*,*/test_*.py"
+    parser: "CoverageParser"
+    order: 6
+    warning_threshold: 0.9
+    error_threshold: 0.5
+    run_in_target_env: true
+    extra_deps:
+      - coverage
+      - pytest
+
+  radon-cc:
+    command: "{python} -m radon cc --json \"{context_path}\""
+    parser: "ComplexityParser"
+    order: 7
+    warning_threshold: 0.6
+    error_threshold: 0.4
+
+  radon-mi:
+    command: "{python} -m radon mi -s --json \"{context_path}\""
+    parser: "MaintainabilityParser"
+    order: 8
+    warning_threshold: 0.6
+    error_threshold: 0.4
+
+  radon-hal:
+    command: "{python} -m radon hal -f --json \"{context_path}\""
+    parser: "HalsteadParser"
+    order: 9
+    warning_threshold: 0.5
+    error_threshold: 0.3
+
+  vulture:
+    command: "{python} -m vulture \"{context_path}\" --min-confidence 80 --exclude .venv,dist,.*_cache,docs,.git"
+    parser: "VultureParser"
+    order: 10
+    warning_threshold: 0.9999
+    error_threshold: 0.8
+
+  interrogate:
+    command: "{python} -m interrogate \"{context_path}\" -v --fail-under 0"
+    parser: "InterrogateParser"
+    order: 11
+    warning_threshold: 0.8
+    error_threshold: 0.3

py_cq/execution_engine.py

@@ -82,7 +82,7 @@ def run_tool(tool_config: ToolConfig, context_path: str) -> RawResult:
         log.info(f"Cache hit: {command}")
         return RawResult(**cast(dict[str, Any], _cache[cache_key]))
     log.info(f"Running: {command}")
-    result = subprocess.run(command, capture_output=True, text=True, shell=True) # nosec
+    result = subprocess.run(command, capture_output=True, text=True, shell=True, encoding="utf-8", errors="replace") # nosec
     timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
     raw_result = RawResult(
         tool_name=tool_config.name,
@@ -96,7 +96,7 @@ def run_tool(tool_config: ToolConfig, context_path: str) -> RawResult:
     return raw_result
 
 
-def run_tools(tool_configs: Collection[ToolConfig], path: str, max_workers: int = 0) -> list[ToolResult]:
+def run_tools(tool_configs: Collection[ToolConfig], path: str, max_workers: int = 0, early_exit: bool = False) -> list[ToolResult]:
     """Run multiple tools and return their parsed results.
 
     Runs each tool specified in *tool_configs* on the file or directory at
@@ -139,14 +139,26 @@ def run_tools(tool_configs: Collection[ToolConfig], path: str, max_workers: int
     def _run_and_parse(tool_config: ToolConfig) -> tuple[int, ToolResult]:
         t0 = time.perf_counter()
         raw_result = run_tool(tool_config, path)
-        tr = tool_config.parser_class().parse(raw_result)
+        tr = tool_config.parser_class(tool_config.parser_config).parse(raw_result)
         tr.duration_s = time.perf_counter() - t0
-        return tool_config.priority, tr
+        return tool_config.order, tr
 
     if not tool_configs:
         return []
     t_start = time.perf_counter()
     prioritized: list[tuple[int, ToolResult]] = []
+    if early_exit:
+        for tool_config in sorted(tool_configs, key=lambda tc: tc.order):
+            try:
+                prioritized.append(_run_and_parse(tool_config))
+            except Exception as exc:
+                log.error(f"{tool_config.name} generated an exception: {exc}")
+                break
+            _, tr = prioritized[-1]
+            if tr.metrics and min(tr.metrics.values()) < tool_config.error_threshold:
+                break
+        log.info(f"run_tools elapsed: {time.perf_counter() - t_start:.2f}s")
+        return [tr for _, tr in sorted(prioritized)]
     with ThreadPoolExecutor(max_workers=max_workers or len(tool_configs)) as executor:
         future_to_tool = {
             executor.submit(_run_and_parse, tool_config): tool_config

py_cq/language_detector.py

@@ -0,0 +1,29 @@
+"""Detect the primary language of a project from its file markers."""
+
+from pathlib import Path
+
+# Ordered: first match wins. Python is listed first so it takes priority.
+_MARKERS: list[tuple[str, list[str]]] = [
+    ("python", ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile"]),
+    ("typescript", ["tsconfig.json", "package.json"]),
+    ("rust", ["Cargo.toml"]),
+    ("go", ["go.mod"]),
+    ("ruby", ["Gemfile"]),
+    ("java", ["pom.xml", "build.gradle"]),
+]
+
+_DOTNET_SUFFIXES = {".csproj", ".sln"}
+
+
+def detect_language(path: Path) -> str | None:
+    """Return the detected language for a project path, or None if unrecognised.
+
+    If path is a file, the parent directory is checked.
+    Dotnet is checked last as it uses suffix matching rather than fixed filenames."""
+    directory = path if path.is_dir() else path.parent
+    for language, markers in _MARKERS:
+        if any((directory / marker).exists() for marker in markers):
+            return language
+    if any(f.suffix in _DOTNET_SUFFIXES for f in directory.iterdir() if f.is_file()):
+        return "dotnet"
+    return None

py_cq/llm_formatter.py

@@ -18,6 +18,7 @@ def format_for_llm(
     tool_configs: dict,
     combined: CombinedToolResults,
     cq_invocation: str | None = None,
+    context_lines: int = 15,
 ) -> str:
     """Return a markdown prompt describing the single most important defect."""
     by_name = {tc.name: tc for tc in tool_configs.values()}
@@ -29,7 +30,7 @@ def format_for_llm(
         ],
         key=lambda tr: (
             _severity(min(tr.metrics.values()), by_name[tr.raw.tool_name]),
-            by_name[tr.raw.tool_name].priority,
+            by_name[tr.raw.tool_name].order,
             min(tr.metrics.values()),
         ),
     )
@@ -38,7 +39,7 @@ def format_for_llm(
 
     worst = failing[0]
     config = by_name[worst.raw.tool_name]
-    defect_md = config.parser_class().format_llm_message(worst)
+    defect_md = config.parser_class().format_llm_message(worst, context_lines=context_lines)
     if cq_invocation is None:
         cq_invocation = "cq " + " ".join(sys.argv[1:])
     return (

py_cq/localtypes.py

@@ -10,17 +10,18 @@ from typing import Any
 
 @dataclass
 class ToolConfig:
-    """Represents the configuration for an analysis tool, including its name, command, parser class, context path, priority, and thresholds for warnings and errors."""
+    """Represents the configuration for an analysis tool, including its name, command, parser class, context path, order, and thresholds for warnings and errors."""
 
     name: str  # e.g., "pytest", "coverage", "pydocstyle"
     command: str  # The command to execute (can include placeholders)
     parser_class: Callable  # Name of the parser class to use
     context_path: str = ""  # Path to project or file
-    priority: int = 5  # 1=critical (compilation), 5=low (style)
+    order: int = 5  # 1=first (compilation), 11=last (style)
     warning_threshold: float = 0.7  # Yellow warning if below this
     error_threshold: float = 0.5  # Red error if below this
     run_in_target_env: bool = False  # If True, run in target project's env via uv
     extra_deps: list[str] = field(default_factory=list)  # Extra deps to inject via uv --with
+    parser_config: dict[str, Any] = field(default_factory=dict)
 
 
 @dataclass
@@ -73,11 +74,11 @@ class ToolResult:
             self.metrics = {}
 
     def to_dict(self) -> dict:
-        """Returns a dictionary containing the metrics, details, and the raw data serialized via its own `to_dict` method."""
+        """Returns a dictionary containing the tool name, metrics, details, and duration."""
         return {
+            "tool_name": self.raw.tool_name,
             "metrics": self.metrics,
             "details": self.details,
-            "raw": self.raw.to_dict(),
             "duration_s": self.duration_s,
         }
 
@@ -119,12 +120,15 @@ class AbstractParser(ABC):
 
     Subclasses must implement `parse` to convert a `RawResult` into a `ToolResult`. An optional `provide_help` can be overridden to supply contextual guidance for a parsed result."""
 
+    def __init__(self, parser_config: dict | None = None):
+        self.parser_config = parser_config or {}
+
     @abstractmethod
     def parse(self, raw_result: RawResult) -> ToolResult:
         """Converts raw tool output into a structured ToolResult."""
         pass
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         """Return a single-defect description for LLM consumption.
 
         Default implementation reports the worst metric by name and score.

py_cq/parsers/banditparser.py

@@ -42,7 +42,7 @@ class BanditParser(AbstractParser):
         score = score_logistic_variant(weighted, scale_factor=10)
         return ToolResult(raw=raw_result, metrics={"security": score}, details=files)
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         if not tr.details:
             return "bandit reported issues (no details available)"
         file, issues = next(iter(tr.details.items()))
@@ -51,4 +51,4 @@ class BanditParser(AbstractParser):
         code = issue.get("code", "")
         severity = issue.get("severity", "")
         message = issue.get("message", "")
-        return f"`{file}:{line}` — **{code}** [{severity}]: {message}{format_source_context(file, line)}"
+        return f"`{file}:{line}` — **{code}** [{severity}]: {message}{format_source_context(file, line, count=context_lines)}"

py_cq/parsers/common.py

@@ -37,6 +37,37 @@ def format_source_context(file: str, line: int | str, context: int = 3, count: i
     return f"\n```python\n{src}\n```"
 
 
+def find_function_source(file: str, func_name: str, max_lines: int = 15) -> str:
+    """Return a fenced python block for the body of func_name, or '' if unavailable."""
+    from pathlib import Path
+    try:
+        all_lines = Path(file).read_text(encoding="utf-8").splitlines()
+    except OSError:
+        return ""
+    import re
+    pattern = re.compile(rf"^(\s*)(?:async\s+)?def\s+{re.escape(func_name)}\s*\(")
+    match_result: tuple[int, int] | None = None
+    for i, line in enumerate(all_lines):
+        m = pattern.match(line)
+        if m:
+            match_result = (i, len(m.group(1)))
+            break
+    if match_result is None:
+        return ""
+    start_idx, baseline_indent = match_result
+    collected = [all_lines[start_idx]]
+    for line in all_lines[start_idx + 1 :]:
+        stripped = line.lstrip()
+        indent = len(line) - len(stripped)
+        if stripped and indent <= baseline_indent:
+            break
+        collected.append(line)
+        if len(collected) >= max_lines:
+            break
+    numbered = "\n".join(f"{start_idx + 1 + i}: {ln}" for i, ln in enumerate(collected))
+    return f"\n```python\n{numbered}\n```"
+
+
 def inv_normalize(value: float, max_value: float) -> float:
     """Returns the inverse normalized value of `value` relative to `max_value`."""
     return (max_value - min(value, max_value)) / max_value

py_cq/parsers/compileparser.py

@@ -115,7 +115,7 @@ class CompileParser(AbstractParser):
             tr.details["failed_files"] = failed_files
         return tr
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         """Return the first compilation failure as a defect description."""
         failed = tr.details.get("failed_files", {})
         if not failed:
@@ -124,5 +124,5 @@ class CompileParser(AbstractParser):
         line = info.get("line", "?")
         typ = info.get("type", "Error")
         help_msg = info.get("help", "")
-        code_block = format_source_context(file, line) or (f"\n```python\n{info['src']}\n```" if info.get("src") else "")
+        code_block = format_source_context(file, line, count=context_lines) or (f"\n```python\n{info['src']}\n```" if info.get("src") else "")
         return f"`{file}:{line}` — **{typ}**: {help_msg}{code_block}"

py_cq/parsers/coverageparser.py

@@ -71,7 +71,7 @@ class CoverageParser(AbstractParser):
         tr.details = details
         return tr
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         """Return the files with lowest coverage as a defect description."""
         score = tr.metrics.get("coverage", 0)
         uncovered = sorted(

py_cq/parsers/exitcodeparser.py

@@ -0,0 +1,16 @@
+"""Parser that scores a tool pass/fail based solely on its exit code."""
+
+from py_cq.localtypes import AbstractParser, RawResult, ToolResult
+
+
+class ExitCodeParser(AbstractParser):
+    """Score 1.0 if the tool exited with code 0, else 0.0."""
+
+    def parse(self, raw_result: RawResult) -> ToolResult:
+        score = 1.0 if raw_result.return_code == 0 else 0.0
+        return ToolResult(raw=raw_result, metrics={"exit_code": score})
+
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
+        output = tr.raw.stdout.strip() or tr.raw.stderr.strip()
+        lines = output.splitlines()[:context_lines]
+        return "\n".join(lines) if lines else "Tool exited with non-zero status (no output)"

py_cq/parsers/halsteadparser.py

@@ -62,7 +62,7 @@ class HalsteadParser(AbstractParser):
         MAX_FILE_BUGS = 1
         MAX_FILE_VOLUME = 2000
         MAX_FUNCTION_BUGS = 0.2
-        MAX_FUNCTION_VOLUME = 300
+        MAX_FUNCTION_VOLUME = 600
         min_file_nb = 1.0
         min_file_sm = 1.0
         min_function_nb = 1.0
@@ -113,7 +113,7 @@ class HalsteadParser(AbstractParser):
         }
         return tr
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         """Return the worst Halstead offender as an actionable defect description."""
         if not tr.metrics:
             return "No Halstead details available"

py_cq/parsers/interrogateparser.py

@@ -42,7 +42,7 @@ class InterrogateParser(AbstractParser):
         score = total_coverage if total_coverage is not None else 1.0
         return ToolResult(raw=raw_result, metrics={"doc_coverage": score}, details=files)
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         score = tr.metrics.get("doc_coverage", 0)
         uncovered = sorted(
             [(f, d) for f, d in tr.details.items() if d.get("missing", 0) > 0],

py_cq/parsers/linecountparser.py

@@ -0,0 +1,26 @@
+"""Parser that scores a tool by counting non-empty output lines as violations."""
+
+from py_cq.localtypes import AbstractParser, RawResult, ToolResult
+from py_cq.parsers.common import score_logistic_variant
+
+
+class LineCountParser(AbstractParser):
+    """Score based on number of non-empty stdout lines.
+
+    parser_config keys:
+        scale_factor (int, default 15): passed to score_logistic_variant.
+    """
+
+    def parse(self, raw_result: RawResult) -> ToolResult:
+        lines = [ln for ln in (raw_result.stdout or "").splitlines() if ln.strip()]
+        count = len(lines)
+        scale = self.parser_config.get("scale_factor", 15)
+        score = score_logistic_variant(count, scale_factor=scale)
+        return ToolResult(raw=raw_result, metrics={"violations": score}, details={"lines": lines})
+
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
+        lines = tr.details.get("lines", [])
+        if not lines:
+            return "No violations found"
+        shown = lines[:context_lines]
+        return "\n".join(shown)