codereview-loop 0.13.0__py3-none-any.whl

codereview/registry.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+"""codereview provider registry — the catalogue of supported LLM
+providers and the per-role model-assignment surface.
+
+One source of truth for every preset: wire kind, base URL, default
+model, the environment variable the user's OWN key is read from
+(BYOK — keys are never stored, logged, or shipped with the tool),
+the vendor FAMILY tag (the independence checks in core — cross-
+family confirmation and the Tech Lead's family-distinctness rule —
+read family from here, never from a seat's display name), default
+extra payload, and per-model request quirks.
+
+Wire kinds:
+  openai-compatible — POST {base}/chat/completions, Bearer auth.
+      Most vendors now expose this shape (OpenAI, DeepSeek,
+      MiniMax, Moonshot/Kimi, NVIDIA NIM, xAI, Mistral,
+      OpenRouter), which is why new majors are one registry row.
+  gemini — the native generateContent API (Google).
+  anthropic — the native Messages API (x-api-key + version header,
+      content-block response).
+
+Spec grammar (consumed by providers.build_provider):
+  preset                — registry default model
+  preset:model          — registry endpoint, caller's model
+  name|type|base|model|KEY_ENV   — fully custom seat (type is
+                          openai-compatible, gemini, or anthropic)
+  openai-compatible:<base>|<model>|<KEY_ENV> — generic escape
+                          hatch for any other compatible endpoint
+  agent:<name>:<command> — a local agent CLI seat (providers.py)
+  local:<name>:<base-url>|<model> — a named LOCAL model server
+                          (Epic L5): any OpenAI-compatible
+                          endpoint the user runs on their own
+                          machine; keyless (no API key, no
+                          key env), family tag 'local'. The
+                          named local presets below (ollama,
+                          lmstudio) are this form with the
+                          conventional endpoint pre-filled.
+
+Roles (owner directive 2026-11-04: the user picks the model for
+each role): correctness, operations (the two review lenses),
+verifier (the verification-round panel), tech-lead (the dispute
+adjudicator seat — its family must stay distinct from the finding's
+raiser and refuter; the registry family tags feed that check), and
+solver (intake mode). Assignment syntax everywhere is
+`--role <role>=<provider-spec>`, repeatable; nothing assigned =
+today's behaviour exactly.
+"""
+
+from __future__ import annotations
+
+# role -> the lens it pins, where the role IS a review lens.
+ROLES = ("correctness", "operations", "verifier", "tech-lead",
+         "tech-lead-shadow", "solver")
+LENS_ROLES = {"correctness": "correctness",
+              "operations": "operations"}
+
+# Each preset:
+#   kind          wire kind (see module docstring)
+#   base_url      API base (None for the gemini native shape, whose
+#                 URL embeds the model)
+#   model         default model suggestion — a starting point, the
+#                 user overrides with preset:model or a custom spec
+#   key_env       env var holding the USER's key for this provider
+#                 (None for the keyless local presets, Epic L5:
+#                 a local server needs no credential and none is
+#                 ever read, sent, or prompted for)
+#   family        vendor family tag for independence checks
+#   extra         extra payload fields merged into every request
+#   no_temperature  model-name prefixes whose API rejects a
+#                 caller-set temperature (the gpt-5 lesson: HTTP
+#                 400 on temperature != default) — for those models
+#                 the field is OMITTED, never faked
+#   completion_tokens  model-name prefixes whose API rejects
+#                 `max_tokens` and requires `max_completion_tokens`
+#                 instead (the second gpt-5 lesson, from the L3
+#                 smoke: the openai preset's default gpt-5-mini
+#                 answered HTTP 400 to every CLI request because
+#                 the payload carried max_tokens) — for those
+#                 models the token cap is sent under the new name
+#   recipe        (local presets only) the short operator recipe
+#                 the setup wizard prints: start the server, then
+#                 pick the preset, then probe with `doctor`
+PRESETS = {
+    "openai": {
+        "kind": "openai-compatible",
+        "base_url": "https://api.openai.com/v1",
+        "model": "gpt-5-mini",
+        "key_env": "OPENAI_API_KEY",
+        "family": "openai",
+        "extra": None,
+        "no_temperature": ("gpt-5", "o1", "o3", "o4"),
+        "completion_tokens": ("gpt-5", "o1", "o3", "o4"),
+    },
+    "gemini": {
+        "kind": "gemini",
+        "base_url": None,
+        "model": "gemini-2.5-flash",
+        "key_env": "GEMINI_API_KEY",
+        "family": "google",
+        "extra": None,
+        "no_temperature": (),
+        "completion_tokens": (),
+    },
+    "anthropic": {
+        "kind": "anthropic",
+        "base_url": "https://api.anthropic.com",
+        "model": "claude-sonnet-4-5",
+        "key_env": "ANTHROPIC_API_KEY",
+        "family": "anthropic",
+        "extra": None,
+        "no_temperature": (),
+        "completion_tokens": (),
+    },
+    "deepseek": {
+        "kind": "openai-compatible",
+        "base_url": "https://api.deepseek.com",
+        "model": "deepseek-chat",
+        "key_env": "DEEPSEEK_API_KEY",
+        "family": "deepseek",
+        "extra": None,
+        "no_temperature": (),
+        "completion_tokens": (),
+    },
+    "minimax": {
+        "kind": "openai-compatible",
+        "base_url": "https://api.minimax.io/v1",
+        "model": "MiniMax-M2",
+        "key_env": "MINIMAX_API_KEY",
+        "family": "minimax",
+        "extra": None,
+        "no_temperature": (),
+        "completion_tokens": (),
+    },
+    "moonshot": {
+        "kind": "openai-compatible",
+        "base_url": "https://api.moonshot.ai/v1",
+        "model": "kimi-k2-0711-preview",
+        "key_env": "MOONSHOT_API_KEY",
+        "family": "moonshot",
+        "extra": None,
+        "no_temperature": (),
+        "completion_tokens": (),
+    },
+    "nvidia": {
+        "kind": "openai-compatible",
+        "base_url": "https://integrate.api.nvidia.com/v1",
+        "model": "nvidia/nemotron-3.5-lightning-30b-a3b",
+        "key_env": "NVIDIA_API_KEY",
+        "family": "nvidia",
+        "extra": {"chat_template_kwargs": {"enable_thinking": False}},
+        "no_temperature": (),
+        "completion_tokens": (),
+    },
+    "xai": {
+        "kind": "openai-compatible",
+        "base_url": "https://api.x.ai/v1",
+        "model": "grok-4-mini",
+        "key_env": "XAI_API_KEY",
+        "family": "xai",
+        "extra": None,
+        "no_temperature": (),
+        "completion_tokens": (),
+    },
+    "mistral": {
+        "kind": "openai-compatible",
+        "base_url": "https://api.mistral.ai/v1",
+        "model": "mistral-large-latest",
+        "key_env": "MISTRAL_API_KEY",
+        "family": "mistral",
+        "extra": None,
+        "no_temperature": (),
+        "completion_tokens": (),
+    },
+    "openrouter": {
+        "kind": "openai-compatible",
+        "base_url": "https://openrouter.ai/api/v1",
+        "model": "anthropic/claude-sonnet-4.5",
+        "key_env": "OPENROUTER_API_KEY",
+        # The router is its own family tag: the MODEL behind a
+        # routed seat varies, so independence checks treat an
+        # OpenRouter seat as family 'openrouter' and users who need
+        # a stricter reading tag the seat with --seat-meta.
+        "family": "openrouter",
+        "extra": None,
+        "no_temperature": (),
+        "completion_tokens": (),
+    },
+    # Local model servers (Epic L5): first-class presets for
+    # endpoints the user runs on their own machine. Keyless by
+    # construction (key_env None — providers.py sends no
+    # Authorization header and reads no credential), family
+    # 'local' for the independence checks (a local seat never
+    # counts as a second VENDOR family), and the endpoints are
+    # the servers' conventional loopback defaults — a preset
+    # names an endpoint, never a panel: which model serves is
+    # still the user's pick (preset:model), exactly like the
+    # hosted presets.
+    "ollama": {
+        "kind": "openai-compatible",
+        "base_url": "http://localhost:11434/v1",
+        "model": "llama3.1",
+        "key_env": None,
+        "family": "local",
+        "extra": None,
+        "no_temperature": (),
+        "completion_tokens": (),
+        "recipe": "start Ollama (`ollama serve`, or open the "
+                  "Ollama app) and pull a model (`ollama pull "
+                  "<model>`), then pick this preset and run "
+                  "`codereview doctor` to probe the seat",
+    },
+    "lmstudio": {
+        "kind": "openai-compatible",
+        "base_url": "http://localhost:1234/v1",
+        "model": "local-model",
+        "key_env": None,
+        "family": "local",
+        "extra": None,
+        "no_temperature": (),
+        "completion_tokens": (),
+        "recipe": "open LM Studio, load a model, and start its "
+                  "local server (Developer tab; default port "
+                  "1234), then pick this preset and run "
+                  "`codereview doctor` to probe the seat",
+    },
+}
+
+WIRE_KINDS = ("openai-compatible", "gemini", "anthropic")
+
+# The family tag every local seat carries (Epic L5): local
+# endpoints are the user's own machines, not a vendor, so the
+# independence checks see one honest tag — two local seats are
+# never two independent families, and a local seat never stands
+# in for a hosted vendor's family.
+LOCAL_FAMILY = "local"
+
+# Prefix of the named-local-endpoint spec form:
+# local:<name>:<base-url>|<model> (providers.describe_spec is
+# the parser; this is the shared spelling).
+LOCAL_SPEC_PREFIX = "local:"
+
+
+def is_local_preset(name):
+    """True for a registry preset that is a local model server
+    (Epic L5): keyless, loopback endpoint, family 'local'."""
+    preset = PRESETS.get(name or "")
+    return bool(preset) and preset.get("family") == LOCAL_FAMILY
+
+
+def local_presets():
+    """{name: preset} for the local presets, in registry
+    order — the setup wizard lists these as their own section,
+    apart from the hosted (keyed) providers."""
+    return {name: p for name, p in PRESETS.items()
+            if p.get("family") == LOCAL_FAMILY}
+
+
+def omit_temperature(preset_name, model):
+    """True when the preset's quirk table says this model rejects a
+    caller-set temperature and the field must be omitted."""
+    preset = PRESETS.get(preset_name or "", {})
+    prefixes = preset.get("no_temperature") or ()
+    return any(str(model).startswith(p) for p in prefixes)
+
+
+def completion_tokens(preset_name, model):
+    """True when the preset's quirk table says this model rejects
+    `max_tokens` and the token cap must be sent as
+    `max_completion_tokens` (OpenAI's gpt-5 / o-series lines)."""
+    preset = PRESETS.get(preset_name or "", {})
+    prefixes = preset.get("completion_tokens") or ()
+    return any(str(model).startswith(p) for p in prefixes)
+
+
+def parse_role_assignments(values):
+    """--role values -> {role: provider-spec}.
+
+    Validates role names against ROLES and rejects a role assigned
+    twice (a silent last-wins would hide a configuration mistake).
+    Raises ValueError with an operator-readable message."""
+    roles = {}
+    for value in values or []:
+        role, eq, spec = str(value).partition("=")
+        role, spec = role.strip().lower(), spec.strip()
+        if not eq or role not in ROLES or not spec:
+            raise ValueError(
+                f"bad --role {value!r}: want <role>=<provider-spec> "
+                f"with role one of {', '.join(ROLES)}")
+        if role in roles:
+            raise ValueError(
+                f"role {role!r} assigned twice ({roles[role]!r} and "
+                f"{spec!r}); assign each role once")
+        roles[role] = spec
+    return roles

codereview/risk.py

@@ -0,0 +1,368 @@
+#!/usr/bin/env python3
+"""Deterministic change-risk scorer — Epic E1 of the adopted
+roadmap.
+
+`risk.scorer` reads a change (the same diff sections the panel
+reviews) and produces a risk score with reasons: which
+sensitive patterns the change touches (auth, payments, crypto,
+migrations, secrets, deserialization), whether dependency
+manifests changed, and how large the change is. The result
+lands in the run record's `risk` section when the project
+policy enables it (the `[risk]` table of `.codereview.toml`,
+validated by policy.py in the B1 style).
+
+Determinism is the contract: the score is a pure function of
+the diff sections and the resolved thresholds. No model calls,
+no randomness, no clock, no environment reads — the same diff
+under the same policy scores identically on every run, on
+every machine. Every point of the score is explained by a
+human-readable reason string, and the per-signal breakdown is
+recorded alongside, so a consumer never has to re-derive why.
+
+Scope of this ticket (E1): the scorer and the record section
+only. The score is descriptive — it never changes a verdict, a
+finding, or any gate input. Tiering (E2) and escalation (E4)
+consume the section next; they read `score` / `band` /
+`signals` from here rather than re-scoring.
+
+What is scored:
+
+  * Sections: the kept diff sections of the run (the ones the
+    panel reviews — archived record artifacts are already
+    excluded by the caller, exactly as for the panel).
+  * Patterns: per class, a file matches when its PATH matches
+    the class's path patterns or any of its ADDED lines matches
+    the class's content patterns (removed lines are not
+    scanned: the score describes what the change introduces
+    and touches, and path matches already cover deletions of
+    sensitive files). A class contributes its points once, no
+    matter how many files match; the pattern subtotal is
+    capped (PATTERN_CAP) so breadth alone cannot max the
+    score.
+  * Dependencies: any changed file whose basename is a known
+    dependency manifest (or a requirements*.txt, or a .txt
+    under a requirements/ directory) contributes
+    DEPENDENCY_POINTS once.
+  * Size: total added + removed lines across all sections,
+    in fixed tiers up to SIZE_MAX_POINTS.
+
+Bands: score >= high threshold is "high", >= medium is
+"medium", otherwise "low". Thresholds default to
+DEFAULT_MEDIUM_THRESHOLD / DEFAULT_HIGH_THRESHOLD and may be
+overridden by the policy's [risk] table.
+"""
+
+from __future__ import annotations
+
+import re
+
+SCHEMA = "codereview.risk/1"
+
+# Band thresholds (defaults; the policy's [risk] table may
+# override either — policy.py mirrors these two constants
+# under the import-free discipline and a test pins the pair).
+DEFAULT_MEDIUM_THRESHOLD = 35
+DEFAULT_HIGH_THRESHOLD = 70
+
+# Points per touched pattern class (awarded once per class)
+# and the cap on the pattern subtotal.
+CLASS_POINTS = {
+    "auth": 25,
+    "payments": 25,
+    "crypto": 20,
+    "migrations": 20,
+    "secrets": 25,
+    "deserialization": 20,
+}
+PATTERN_CAP = 60
+
+# Dependency-manifest changes.
+DEPENDENCY_POINTS = 15
+
+# Size tiers: (minimum changed lines, points), descending.
+SIZE_TIERS = ((1000, 25), (400, 15), (150, 10), (50, 5))
+SIZE_MAX_POINTS = 25
+
+# How many matching files a reason names before summarising
+# the rest ("+N more").
+_REASON_FILE_LIMIT = 5
+
+# ----------------------------------------------------------------
+# Pattern classes, in the fixed order reasons are reported.
+# Path patterns match the repo-relative path (lowercased);
+# content patterns match added lines (case-insensitive).
+
+_PATH_PATTERNS = {
+    "auth": re.compile(
+        r"(^|/)(auth|authn|authz|login|logout|signin|signup|"
+        r"sessions?|oauth|oidc|rbac|acl|permissions?)([./_-]|$)"),
+    "payments": re.compile(
+        r"(^|/)(payments?|billing|checkout|invoices?|charges?|"
+        r"refunds?|subscriptions?|stripe|paypal|pricing)"
+        r"([./_-]|$)"),
+    "crypto": re.compile(
+        r"(^|/)(crypto|crypt|encryption|decrypt|ciphers?|"
+        r"hashing)([./_-]|$)"),
+    # P2-05: migrations / secrets / deserialization are
+    # component-anchored like the auth/payments/crypto rules
+    # above — a keyword buried inside a longer component
+    # ("im**migration**", "no**secrets**.py") must not score.
+    "migrations": re.compile(
+        r"(^|/)migrations?([./_-]|$)|(^|/)alembic(/|$)|"
+        r"(^|/)flyway(/|$)|(^|/)liquibase(/|$)"),
+    "secrets": re.compile(
+        r"(^|/)(secrets?|credentials?)(\.|/|_|-|$)|"
+        r"(^|/)\.env(\.|$)"),
+    "deserialization": re.compile(r"(^|/)deserial"),
+}
+
+_CONTENT_PATTERNS = {
+    "auth": re.compile(
+        r"\b(authenticate|authentication|authorization|"
+        r"login_required|permission_required|check_password|"
+        r"make_password|jwt|oauth|login_user|current_user|"
+        r"set_cookie)\b", re.IGNORECASE),
+    "payments": re.compile(
+        r"\b(stripe|paypal|braintree|adyen|cvv|cvc|"
+        r"card_number|payment_intent|paymentintent|"
+        r"payment_method)\b", re.IGNORECASE),
+    "crypto": re.compile(
+        r"\b(hashlib|bcrypt|argon2|scrypt|pbkdf2|fernet|"
+        r"createcipher|createdecipher|messagedigest|hmac|"
+        r"encrypt|decrypt)\b", re.IGNORECASE),
+    # \s+ rather than a literal space: the phrases are SQL
+    # whatever the whitespace, and the pattern text itself
+    # then carries no literal destructive-SQL string for a
+    # scanner to mistake for a statement.
+    "migrations": re.compile(
+        r"\b(alter\s+table|create\s+table|drop\s+table|"
+        r"add\s+column|drop\s+column|create\s+index|"
+        r"drop\s+index)\b",
+        re.IGNORECASE),
+    "secrets": re.compile(
+        r"(api[_-]?key|secret|password|passwd|private[_-]?key|"
+        r"aws_secret_access_key)\s*[:=]|"
+        r"-----BEGIN [A-Z ]*PRIVATE KEY-----|AKIA[0-9A-Z]{16}",
+        re.IGNORECASE),
+    "deserialization": re.compile(
+        r"\b(pickle\.loads?|marshal\.loads?|dill\.loads?|"
+        r"yaml\.load\(|unserialize\s?\(|objectinputstream|"
+        r"readobject\s?\(|binaryformatter)\b", re.IGNORECASE),
+}
+
+# Class order for reasons and the signals ledger: the ticket's
+# order, fixed so output never depends on dict iteration.
+CLASS_ORDER = tuple(CLASS_POINTS)
+
+# Dependency manifests by basename (plus the requirements
+# rule in _is_dependency_manifest).
+DEPENDENCY_MANIFESTS = frozenset({
+    "package.json", "package-lock.json", "yarn.lock",
+    "pnpm-lock.yaml", "npm-shrinkwrap.json",
+    "requirements.txt", "pipfile", "pipfile.lock",
+    "pyproject.toml", "setup.py", "setup.cfg", "poetry.lock",
+    "uv.lock", "gemfile", "gemfile.lock", "go.mod", "go.sum",
+    "cargo.toml", "cargo.lock", "composer.json",
+    "composer.lock", "pom.xml", "build.gradle",
+    "build.gradle.kts", "packages.lock.json",
+})
+
+_REQUIREMENTS_RE = re.compile(r"requirements[^/]*\.txt$")
+
+
+def _is_dependency_manifest(path):
+    lowered = (path or "").lower()
+    base = lowered.rsplit("/", 1)[-1]
+    if base in DEPENDENCY_MANIFESTS \
+            or _REQUIREMENTS_RE.match(base):
+        return True
+    # The requirements/<env>.txt layout: a .txt inside a
+    # requirements directory is a manifest whatever its name.
+    parts = lowered.split("/")
+    return "requirements" in parts[:-1] \
+        and base.endswith(".txt")
+
+
+def _section_lines(section_text):
+    """(added_texts, added_count, removed_count) for one diff
+    section, using the same line convention as core.added_lines:
+    a line starting with '+' is an addition unless it starts
+    with '+++' (the +++ header), likewise '-' / '---'."""
+    added_texts = []
+    removed = 0
+    for raw in (section_text or "").splitlines():
+        if raw.startswith("+") and not raw.startswith("+++"):
+            added_texts.append(raw[1:])
+        elif raw.startswith("-") and not raw.startswith("---"):
+            removed += 1
+    return added_texts, len(added_texts), removed
+
+
+def _name_files(files):
+    """A deterministic file list for a reason string: sorted,
+    capped at _REASON_FILE_LIMIT names plus a '+N more' tail."""
+    names = sorted(files)
+    if len(names) <= _REASON_FILE_LIMIT:
+        return ", ".join(names)
+    return ", ".join(names[:_REASON_FILE_LIMIT]) \
+        + f", +{len(names) - _REASON_FILE_LIMIT} more"
+
+
+def risk_config(policy):
+    """The resolved scorer config carried by a loaded policy
+    dict, or None when risk scoring is not enabled (no policy,
+    no [risk] table, or enabled = false) — the caller then
+    leaves the record exactly as it was before Epic E1.
+
+    Defensive by construction, mirroring hooks_from_policy:
+    a hand-built policy dict with missing or mistyped values
+    resolves to the defaults rather than raising mid-run; the
+    validating layer is policy.load_policy."""
+    if not isinstance(policy, dict):
+        return None
+    risk = policy.get("risk") or {}
+    if not isinstance(risk, dict) or not risk.get("enabled"):
+        return None
+
+    def _threshold(key, default):
+        value = risk.get(key)
+        if isinstance(value, bool) \
+                or not isinstance(value, int) \
+                or not 0 <= value <= 100:
+            return default
+        return value
+
+    return {
+        "medium_threshold": _threshold(
+            "medium_threshold", DEFAULT_MEDIUM_THRESHOLD),
+        "high_threshold": _threshold(
+            "high_threshold", DEFAULT_HIGH_THRESHOLD),
+    }
+
+
+def band_for(score, config=None):
+    """The band for a score under a resolved config (or the
+    default thresholds)."""
+    config = config or {}
+    medium = config.get("medium_threshold",
+                        DEFAULT_MEDIUM_THRESHOLD)
+    high = config.get("high_threshold", DEFAULT_HIGH_THRESHOLD)
+    if score >= high:
+        return "high"
+    if score >= medium:
+        return "medium"
+    return "low"
+
+
+def score_sections(sections, config=None):
+    """Score a change from its diff sections.
+
+    `sections` is a list of (path, section_text) pairs — the
+    shape core.split_patch_sections returns and run_review
+    already holds. `config` is a resolved config from
+    risk_config (or None for the default thresholds).
+
+    Returns the run record's `risk` section:
+    {"schema", "score", "band", "reasons", "points",
+     "signals", "thresholds"} — see the module docstring for
+    the scoring rules. Pure: no I/O, no clock, no randomness.
+    """
+    config = config or {}
+    medium = config.get("medium_threshold",
+                        DEFAULT_MEDIUM_THRESHOLD)
+    high = config.get("high_threshold", DEFAULT_HIGH_THRESHOLD)
+
+    class_files = {name: [] for name in CLASS_ORDER}
+    dependency_files = []
+    files_changed = 0
+    lines_added = 0
+    lines_removed = 0
+    for path, text in sections or []:
+        files_changed += 1
+        added_texts, n_added, n_removed = _section_lines(text)
+        lines_added += n_added
+        lines_removed += n_removed
+        lowered = (path or "").lower()
+        for name in CLASS_ORDER:
+            if _PATH_PATTERNS[name].search(lowered):
+                class_files[name].append(path)
+                continue
+            content_re = _CONTENT_PATTERNS[name]
+            if any(content_re.search(line)
+                   for line in added_texts):
+                class_files[name].append(path)
+        if _is_dependency_manifest(path):
+            dependency_files.append(path)
+
+    reasons = []
+    pattern_signals = []
+    pattern_points = 0
+    for name in CLASS_ORDER:
+        files = sorted(set(class_files[name]))
+        if not files:
+            continue
+        points = CLASS_POINTS[name]
+        pattern_points += points
+        pattern_signals.append({
+            "class": name, "points": points, "files": files})
+        reasons.append(
+            f"{name} patterns touched in {len(files)} file(s): "
+            f"{_name_files(files)} (+{points})")
+    if pattern_points > PATTERN_CAP:
+        reasons.append(
+            f"pattern subtotal capped at {PATTERN_CAP} "
+            f"(uncapped {pattern_points})")
+        pattern_points = PATTERN_CAP
+
+    dependency_points = 0
+    dependency_files = sorted(set(dependency_files))
+    if dependency_files:
+        dependency_points = DEPENDENCY_POINTS
+        reasons.append(
+            f"dependency manifests changed: "
+            f"{_name_files(dependency_files)} "
+            f"(+{dependency_points})")
+
+    changed_lines = lines_added + lines_removed
+    size_points = 0
+    for minimum, points in SIZE_TIERS:
+        if changed_lines >= minimum:
+            size_points = points
+            break
+    if size_points:
+        reasons.append(
+            f"change size: {changed_lines} changed line(s) "
+            f"(+{size_points})")
+
+    score = min(100, pattern_points + dependency_points
+                + size_points)
+    if not reasons:
+        reasons.append("no risk signals detected")
+    return {
+        "schema": SCHEMA,
+        "score": score,
+        "band": band_for(score, {"medium_threshold": medium,
+                                 "high_threshold": high}),
+        "reasons": reasons,
+        "points": {"patterns": pattern_points,
+                   "dependencies": dependency_points,
+                   "size": size_points},
+        "signals": {
+            "files_changed": files_changed,
+            "lines_added": lines_added,
+            "lines_removed": lines_removed,
+            "patterns": pattern_signals,
+            "dependency_files": dependency_files,
+        },
+        "thresholds": {"medium": medium, "high": high},
+    }
+
+
+def score_patch(patch, config=None):
+    """Score a raw unified-diff string — score_sections over
+    core.split_patch_sections(patch). The import lives inside
+    this function so the module stays importable on its own
+    (core imports this module only at function level too, so
+    the module graph stays one-directional)."""
+    from .core import split_patch_sections
+    return score_sections(split_patch_sections(patch), config)