jitcatch 0.2.0__py3-none-any.whl

jitcatch/config.py

@@ -0,0 +1,259 @@
+"""Configuration loading for `.jitcatch.toml`."""
+from __future__ import annotations
+
+import copy
+import os
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+CONFIG_FILENAMES = (".jitcatch.toml", "jitcatch.toml")
+
+# Provider presets: fill in type/base_url/auth/api_key_env. `model` is always user-chosen.
+PRESETS: dict[str, dict[str, Any]] = {
+    "anthropic": {
+        "type": "anthropic",
+        "base_url": "https://api.anthropic.com",
+        "api_key_env": "ANTHROPIC_API_KEY",
+        "auth": "x-api-key",
+    },
+    "openai": {
+        "type": "openai_responses",
+        "base_url": "https://api.openai.com/v1",
+        "api_key_env": "OPENAI_API_KEY",
+    },
+    "openai-chat": {
+        "type": "openai_chat",
+        "base_url": "https://api.openai.com/v1",
+        "api_key_env": "OPENAI_API_KEY",
+    },
+    # Z.ai GLM Coding Plan (dedicated coding endpoints; Coding Plan keys only work here).
+    # GLM-5.x always thinks (GLM-5.3/5.3-Flash cannot disable it) and reasoning tokens count against
+    # max_tokens, so use Z.ai's documented default budget (65536; max 131072) and recommended temperature 1.0.
+    "zai-coding": {
+        "type": "openai_chat",
+        "base_url": "https://api.z.ai/api/coding/paas/v4",
+        "api_key_env": "ZAI_API_KEY",
+        "max_tokens": 65536,
+        "temperature": 1.0,
+    },
+    "zai-coding-anthropic": {
+        "type": "anthropic",
+        "base_url": "https://api.z.ai/api/anthropic",
+        "api_key_env": "ZAI_API_KEY",
+        "auth": "bearer",
+        "max_tokens": 65536,
+        "temperature": 1.0,
+    },
+    "zai-coding-responses": {
+        "type": "openai_responses",
+        "base_url": "https://api.z.ai/api/v1",
+        "api_key_env": "ZAI_API_KEY",
+        "max_tokens": 65536,
+        "temperature": 1.0,
+    },
+    # Local models via OpenAI-compatible servers.
+    "ollama": {
+        "type": "openai_chat",
+        "base_url": "http://localhost:11434/v1",
+        "api_key_env": "",
+    },
+    "lmstudio": {
+        "type": "openai_chat",
+        "base_url": "http://localhost:1234/v1",
+        "api_key_env": "",
+    },
+    "vllm": {
+        "type": "openai_chat",
+        "base_url": "http://localhost:8000/v1",
+        "api_key_env": "",
+    },
+}
+
+DEFAULTS: dict[str, Any] = {
+    "providers": {},
+    "roles": {"generator": None, "judges": [], "logprob_judge": None},
+    "run": {
+        "workflows": ["intent_aware", "dodgy_diff"],
+        "max_target_files": 5,
+        "max_risks_per_file": 4,
+        "dodgy_tests_per_file": 2,
+        "max_fix_attempts": 2,
+        "check_mutants_with_existing_tests": True,
+        "flaky_reruns": 1,
+        "max_file_chars": 40000,
+        "max_patch_chars": 30000,
+        "test_timeout_s": 300,
+        "existing_tests_timeout_s": 900,
+        "min_risk_score": 0.0,
+        "report_threshold": 0.2,
+        "output_dir": ".jitcatch",
+        "link_paths": ["node_modules"],
+        "include": [],
+        "exclude": [],
+    },
+    "assessors": {
+        "weights": {"rules": 1.0, "llm_bucket": 1.0, "llm_logprob": 1.0},
+        "discard_on_high_fp_rule": True,
+        "rule_overrides": {},
+    },
+    "targeting": {
+        "sensitive_paths": [
+            "auth", "security", "permission", "acl", "rbac", "payment", "billing",
+            "crypto", "token", "session", "migration", "privacy",
+        ],
+    },
+    "adapters": {
+        "python": {"enabled": True, "python": None, "extra_args": []},
+        "typescript": {"enabled": True, "runner": "auto", "extra_args": []},
+        "java": {"enabled": True, "build": "auto", "extra_args": []},
+        "go": {"enabled": True, "extra_args": []},
+    },
+    "hook": {"blocking": False, "default_branch": None},
+}
+
+
+class ConfigError(ValueError):
+    pass
+
+
+@dataclass
+class ProviderConfig:
+    name: str
+    type: str
+    base_url: str
+    model: str
+    api_key_env: str = ""
+    api_key: str = ""
+    auth: str = "bearer"
+    max_tokens: int = 8192
+    temperature: float | None = 0.2
+    timeout_s: float = 300.0
+    max_retries: int = 4
+    logprobs: bool = False
+    extra_headers: dict[str, str] = field(default_factory=dict)
+    extra_body: dict[str, Any] = field(default_factory=dict)
+    # Request-shape knobs for picky servers, e.g. OpenAI reasoning models on Chat Completions
+    # need max_tokens_field = "max_completion_tokens" and omit_params = ["temperature"].
+    max_tokens_field: str = ""
+    omit_params: list[str] = field(default_factory=list)
+
+    def resolve_api_key(self) -> str:
+        if self.api_key:
+            return self.api_key
+        if self.api_key_env:
+            from .userconfig import stored_key
+            return os.environ.get(self.api_key_env, "") or stored_key(self.api_key_env)
+        return ""
+
+
+@dataclass
+class Config:
+    raw: dict[str, Any]
+    providers: dict[str, ProviderConfig]
+    root: Path
+
+    @property
+    def run(self) -> dict[str, Any]:
+        return self.raw["run"]
+
+    @property
+    def roles(self) -> dict[str, Any]:
+        return self.raw["roles"]
+
+    @property
+    def assessors(self) -> dict[str, Any]:
+        return self.raw["assessors"]
+
+    @property
+    def targeting(self) -> dict[str, Any]:
+        return self.raw["targeting"]
+
+    @property
+    def adapters(self) -> dict[str, Any]:
+        return self.raw["adapters"]
+
+    @property
+    def hook(self) -> dict[str, Any]:
+        return self.raw["hook"]
+
+    def output_dir(self) -> Path:
+        p = Path(self.run["output_dir"])
+        return p if p.is_absolute() else self.root / p
+
+
+def _deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    out = copy.deepcopy(base)
+    for k, v in override.items():
+        if isinstance(v, dict) and isinstance(out.get(k), dict):
+            out[k] = _deep_merge(out[k], v)
+        else:
+            out[k] = copy.deepcopy(v)
+    return out
+
+
+def find_config(start: Path) -> Path | None:
+    for d in [start, *start.parents]:
+        for name in CONFIG_FILENAMES:
+            p = d / name
+            if p.is_file():
+                return p
+    return None
+
+
+def load_config(repo_root: Path, path: Path | None = None, overrides: dict[str, Any] | None = None) -> Config:
+    data: dict[str, Any] = {}
+    cfg_path = path or find_config(repo_root)
+    if cfg_path is not None:
+        with open(cfg_path, "rb") as f:
+            data = tomllib.load(f)
+    from .userconfig import load_user_config
+    merged = _deep_merge(_deep_merge(DEFAULTS, load_user_config()), data)
+    if overrides:
+        merged = _deep_merge(merged, overrides)
+    providers = {name: _build_provider(name, spec) for name, spec in merged["providers"].items()}
+    cfg = Config(raw=merged, providers=providers, root=repo_root)
+    _validate(cfg)
+    return cfg
+
+
+def _build_provider(name: str, spec: dict[str, Any]) -> ProviderConfig:
+    spec = dict(spec)
+    preset = spec.pop("preset", None)
+    if preset is not None:
+        if preset not in PRESETS:
+            raise ConfigError(f"provider {name!r}: unknown preset {preset!r}; known: {sorted(PRESETS)}")
+        spec = {**PRESETS[preset], **spec}
+    for required in ("type", "base_url", "model"):
+        if not spec.get(required):
+            raise ConfigError(f"provider {name!r}: missing required field {required!r}")
+    if spec["type"] not in ("anthropic", "openai_chat", "openai_responses"):
+        raise ConfigError(f"provider {name!r}: type must be anthropic, openai_chat or openai_responses")
+    if spec["type"] == "anthropic":
+        spec.setdefault("auth", "x-api-key")
+    known = set(ProviderConfig.__dataclass_fields__) - {"name"}
+    unknown = set(spec) - known
+    if unknown:
+        raise ConfigError(f"provider {name!r}: unknown fields {sorted(unknown)}")
+    return ProviderConfig(name=name, **spec)
+
+
+def _validate(cfg: Config) -> None:
+    roles = cfg.roles
+    names = set(cfg.providers)
+    refs = [roles.get("generator")] + list(roles.get("judges") or []) + [roles.get("logprob_judge")]
+    for r in refs:
+        if r is not None and r not in names:
+            raise ConfigError(f"roles reference unknown provider {r!r}; defined: {sorted(names)}")
+    lp = roles.get("logprob_judge")
+    if lp is not None:
+        p = cfg.providers[lp]
+        if p.type != "openai_chat" or not p.logprobs:
+            raise ConfigError(
+                f"logprob_judge {lp!r} must be an openai_chat provider with logprobs = true "
+                "(token log-probabilities are only read from Chat Completions responses)"
+            )
+    for wf in cfg.run["workflows"]:
+        if wf not in ("intent_aware", "dodgy_diff"):
+            raise ConfigError(f"unknown workflow {wf!r}")