ThothII/harness/tht/config.py

import os
import re
from pathlib import Path
from typing import Any, Literal

import yaml
from pydantic import BaseModel, Field, ValidationError

_ENV_RE = re.compile(r"\$\{([A-Za-z_][A-Za-z0-9_]*)\}")


class ConfigError(Exception):
    """Errore di configurazione, con messaggio leggibile per l'utente."""


def _expand_env(value: Any) -> Any:
    if isinstance(value, str):
        def repl(m: re.Match) -> str:
            var = m.group(1)
            if var not in os.environ:
                raise ConfigError(
                    f"Variabile d'ambiente non definita: {var} "
                    f"(definiscila nel file .env o nell'ambiente)"
                )
            return os.environ[var]

        return _ENV_RE.sub(repl, value)
    if isinstance(value, dict):
        return {k: _expand_env(v) for k, v in value.items()}
    if isinstance(value, list):
        return [_expand_env(v) for v in value]
    return value


class DatabaseConfig(BaseModel):
    host: str = "localhost"
    port: int = 5432
    database: str
    db_schema: str = Field(alias="schema")
    user: str
    password: str
    # transport: `direct` (Postgres via SQLAlchemy) o `rest` (Supabase/PostgREST).
    # In `rest` deve esistere la sezione `rest` (validato a livello di Config).
    transport: Literal["direct", "rest"] = "direct"

    model_config = {"populate_by_name": True}


class RestConfig(BaseModel):
    """Accesso al DWH via Supabase/PostgREST. base_url es. https://host/dwh/ ."""

    base_url: str
    api_key: str
    timeout: int = 30
    ssl_ca: str | None = None  # path al certificato CA (per server con CA interna)


class PathsConfig(BaseModel):
    artifacts: Path = Path("artifacts")
    indexes: Path = Path("indexes")
    sessions: Path = Path("sessions")


class ExamplesConfig(BaseModel):
    max_per_column: int = 10


class LshSkipConfig(BaseModel):
    # DEPRECATO: l'euristica di lunghezza (skip_column vendored) non è più usata. La
    # selezione delle colonne da indicizzare segue il principio di column eligibility
    # (sezione `eligibility`). Mantenuto solo per compatibilità con tht.yaml esistenti.
    max_total_chars: int = 50000
    max_avg_length: int = 20


class LshConfig(BaseModel):
    signature_size: int = 64
    n_gram: int = 3
    threshold: float = 0.5
    max_values_per_column: int = 1000
    skip: LshSkipConfig = LshSkipConfig()


class EligibilityConfig(BaseModel):
    # Soglie del principio di column eligibility (testo ampio ignorato ovunque).
    max_declared_len: int = 128   # char/varchar dichiarati <= soglia: eligible senza campionare
    max_avg_length: int = 40      # fallback data-driven: lunghezza media valori campionati
    max_sampled_len: int = 200    # fallback data-driven: lunghezza massima valore campionato
    # Colonne di servizio sempre ignorate per nome (match case-insensitive), a prescindere
    # dal tipo: metadati ETL/audit non analitici (es. timestamp di ultimo aggiornamento).
    ignore_columns: list[str] = ["etl_last_update"]


class EvidenceSourcesConfig(BaseModel):
    source_root: Path
    # cartella curata a mano nell'ETL (relativa a source_root): unica fonte delle
    # evidence. Niente piu' estrazione automatica dalle schede tabella: i documenti
    # qui dentro sono gia' evidence pronte (frontmatter + corpo), scelte e arricchite
    # dall'autore ETL e organizzate in sottocartelle per dominio.
    evidence_dir: str = "evidence"


class EmbeddingsConfig(BaseModel):
    base_url: str
    model: str = "nomic-embed-text-v2-moe"
    dim: int = 768
    batch_size: int = 32
    timeout: int = 120
    bin: str = "ollama"
    start_cmd: list[str] | None = None


class VectorConfig(BaseModel):
    max_chunk_chars: int = 4000


class SearchConfig(BaseModel):
    rrf_k: int = 60
    top_schema_tables: int = 12   # default `--top` per `tht search --kind schema` (n. tabelle)
    schema_chunk_pool: int = 150  # chunk tabella/colonna fusi prima dell'aggregazione a tabella


class ExecutionConfig(BaseModel):
    allow: list[str] = ["cte_test", "explain", "preview", "aggregate", "export"]
    max_preview_rows: int = 10
    statement_timeout_ms: int = 30000
    warn_execution_ms: int = 5000
    warn_plan_rows: int = 1_000_000
    max_aggregate_cells: int = 20
    max_export_rows: int = 100000
    forbidden_functions: list[str] = [
        "setval", "nextval", "pg_advisory_lock", "pg_advisory_xact_lock",
        "dblink", "dblink_exec", "pg_terminate_backend", "pg_cancel_backend",
        "lo_import", "lo_export", "pg_reload_conf",
    ]


class Config(BaseModel):
    database: DatabaseConfig
    # Profilo dell'installazione, letto da THT_PROFILE (.env), non dallo yaml versionato.
    # server: ricostruisce i derivati (artefatti, LSH, vettori schema nel vectordb).
    # workstation: postazione locale che legge il vectordb via REST; gli upsert remoti
    # richiedono vector_write_rest, mentre init/clear/rebuild restano solo-server.
    profile: Literal["server", "workstation"] = "server"
    # Language in which table/column descriptions and evidence are written. The skill
    # instructions stay in English; only content/output follow this language. Default
    # 'en' so Thoth is not bound to any customer's language.
    language: str = "en"
    paths: PathsConfig = PathsConfig()
    examples: ExamplesConfig = ExamplesConfig()
    lsh: LshConfig = LshConfig()
    eligibility: EligibilityConfig = EligibilityConfig()
    evidence: EvidenceSourcesConfig | None = None
    embeddings: EmbeddingsConfig | None = None
    vector_db: DatabaseConfig | None = None
    vector: VectorConfig = VectorConfig()
    search: SearchConfig = SearchConfig()
    execution: ExecutionConfig = ExecutionConfig()
    rest: RestConfig | None = None
    # Endpoint REST dedicato per la similarity search del pgvector (rpc search_similar).
    # Se presente, `tht search` legge via REST; altrimenti legge in diretto (dev/test).
    vector_rest: RestConfig | None = None
    # Endpoint REST dedicato alle scritture controllate del pgvector. E' opzionale e usa
    # una API key separata dalla lettura; espone solo upsert/hash via RPC allowlist.
    vector_write_rest: RestConfig | None = None


def load_config(path: Path) -> Config:
    if not path.exists():
        raise ConfigError(f"File di configurazione non trovato: {path}")
    raw = yaml.safe_load(path.read_text())
    if not isinstance(raw, dict):
        raise ConfigError(f"Configurazione non valida (atteso un mapping YAML): {path}")
    try:
        cfg = Config.model_validate(_expand_env(raw))
    except ValidationError as e:
        raise ConfigError(f"Configurazione non valida in {path}:\n{e}") from e
    env_profile = os.environ.get("THT_PROFILE")
    if env_profile is not None:
        if env_profile not in ("server", "workstation"):
            raise ConfigError(
                f"THT_PROFILE non valido: {env_profile!r} (atteso 'server' o 'workstation')."
            )
        cfg = cfg.model_copy(update={"profile": env_profile})
    if cfg.database.transport == "rest" and cfg.rest is None:
        raise ConfigError(
            f"transport: rest richiede la sezione `rest` (base_url, api_key) in {path}."
        )
    return cfg