+-----------------------------------------------------------+
|                  КОНВЕЙЕР ГИПОТЕЗ                           |
+-----------------------------------------------------------+

1. ГЕНЕРАЦИЯ
   HypothesisGenerator.generate()
   +-- База данных CWE (более 120 шаблонов)
   +-- База данных CAPEC (более 50 шаблонов атак)
   +-- Языковые шаблоны (C, Python, Java)
   +-- Декартово произведение: CWE × CAPEC × шаблоны
   +-- Инстанцирование шаблонов
   +-- Результат: SecurityHypothesis[]

2. ОЦЕНКА
   MultiCriteriaScorer.score_batch()
   +-- Оценка частоты CWE (вес 0,40)
   +-- Оценка схожести атаки (вес 0,30)
   +-- Оценка экспозиции кодовой базы (вес 0,30)
   +-- Бонусы: наличие известных CVE, критическая серьёзность
   +-- Результат: приоритетные оценки [0,0–1,0]

3. СИНТЕЗ ЗАПРОСОВ
   QuerySynthesizer.synthesize()
   +-- Сопоставление гипотезы с шаблоном SQL
   +-- Подстановка параметров
   +-- Результат: SQL-запросы DuckDB / PGQ

4. ВЫПОЛНЕНИЕ
   HypothesisExecutor.execute()
   +-- Выполнение запросов к CPG
   +-- Сбор доказательств
   +-- Результат: Evidence[]

5. ВАЛИДАЦИЯ
   HypothesisValidator.validate()
   +-- Анализ доказательств
   +-- Обновление статуса гипотезы
   +-- Расчёт метрик
   +-- Результат: ValidationResults

@dataclass
class SecurityHypothesis:
    id: str                          # Уникальный идентификатор
    hypothesis_text: str             # Читаемое утверждение

    # Классификация
    cwe_ids: List[str]              # ["CWE-120", "CWE-119"]
    capec_ids: List[str]            # ["CAPEC-100"]
    language: str                   # "C", "Python" и т.д.
    category: str                   # "buffer_overflow", "injection"

    # Шаблоны передачи заражённых данных (taint)
    source_patterns: List[str]      # ["PQgetvalue", "getenv"]
    sink_patterns: List[str]        # ["strcpy", "memcpy"]
    sanitizer_patterns: List[str]   # ["strlcpy", "sizeof"]

    # Оценки
    priority_score: float           # 0.0–1.0, общая важность
    confidence: float               # 0.0–1.0, достоверность гипотезы

    # Детализация по нескольким критериям
    cwe_frequency_score: float
    attack_similarity_score: float
    codebase_exposure_score: float

    # Сгенерированный SQL-запрос
    sql_query: Optional[str]

    # Подтверждение
    evidence: List[Evidence]
    validation_status: ValidationStatus

@dataclass
class Evidence:
    id: str
    hypothesis_id: str
    query_executed: str             # SQL-запрос, который нашёл это
    result_count: int
    findings: List[Dict[str, Any]]  # Результаты запроса
    filename: Optional[str]
    line_number: Optional[int]
    code_snippet: Optional[str]
    confidence: float               # 0.0–1.0

class ValidationStatus(Enum):
    PENDING = "pending"
    IN_PROGRESS = "in_progress"
    CONFIRMED = "confirmed"
    REJECTED = "rejected"
    INCONCLUSIVE = "inconclusive"

class Severity(Enum):
    CRITICAL = "critical"
    HIGH = "high"
    MEDIUM = "medium"
    LOW = "low"
    INFO = "info"

"Если [источник] передаёт данные в [приёмник] без [средства очистки], то [CWE] позволяет осуществить [атаку]"

from src.security.hypothesis import HypothesisGenerator

generator = HypothesisGenerator()

# Генерация для конкретного CWE {#generate-for-specific-cwe}
hypotheses = generator.generate(
    language="C",
    cwe_filter=["CWE-120", "CWE-78"],
    max_hypotheses=50
)

# Генерация по категории {#generate-for-category}
buffer_hypotheses = generator.generate_by_category("buffer_overflow")

# Полное перечисление {#full-enumeration}
all_hypotheses = generator.generate_all(language="C")

Приоритет = (Частота_CWE × 0.40)
          + (Схожесть_атаки × 0.30)
          + (Экспозиция_кода × 0.30)

from src.security.hypothesis import MultiCriteriaScorer, CodebaseStats

# Сбор статистики по кодовой базе {#gather-codebase-statistics}
stats = CodebaseStats(
    total_methods=52000,
    total_calls=110000,
    sink_counts={"strcpy": 150, "memcpy": 800},
    source_counts={"getenv": 50, "recv": 30}
)

# Оценка гипотез {#score-hypotheses}
scorer = MultiCriteriaScorer(weights={
    'cwe_frequency': 0.40,
    'attack_similarity': 0.30,
    'codebase_exposure': 0.30
})

scored_hypotheses = scorer.score_batch(hypotheses, stats)

# Получение наиболее приоритетных {#get-top-priority}
top_10 = sorted(scored_hypotheses, key=lambda h: h.priority_score, reverse=True)[:10]

from src.security.hypothesis import QuerySynthesizer

synthesizer = QuerySynthesizer()
query = synthesizer.synthesize_query(hypothesis)

SELECT DISTINCT nc.id, nc.name AS sink_function, nc.code,
       nc.filename, nc.line_number
FROM nodes_call nc
WHERE nc.name IN ('strcpy', 'strcat', 'sprintf', 'memcpy')
LIMIT 100;

SELECT DISTINCT nc.id, nc.name AS sink_function, nc.code,
       nc.filename, nc.line_number
FROM nodes_call nc
WHERE nc.name IN ('system', 'popen', 'execl', 'execv')
LIMIT 100;

FROM GRAPH_TABLE(cpg
    MATCH (src:IDENTIFIER)-[:REACHING_DEF*1..5]->(sink:CALL_NODE)
    WHERE src.name IN ('user_input', 'request')
      AND sink.name IN ('execute', 'query')
    COLUMNS (
        src.name AS source_var,
        sink.name AS sink_function,
        sink.filename,
        sink.line_number
    )
)
LIMIT 100;

from src.security.hypothesis import HypothesisExecutor
import duckdb

conn = duckdb.connect("cpg.duckdb")
executor = HypothesisExecutor(conn)

# Выполнить одну гипотезу {#execute-single-hypothesis}
evidence = executor.execute(hypothesis)

# Выполнить пакетно {#execute-batch}
results = executor.execute_batch(hypotheses, parallel=True)

from src.security.hypothesis import HypothesisValidator

validator = HypothesisValidator()

# Валидация одной гипотезы {#validate-single-hypothesis}
validator.validate(hypothesis)

# Валидация пакета {#validate-batch}
results = validator.validate_batch(hypotheses)

@dataclass
class ValidationResults:
    batch_id: str
    total_hypotheses: int
    executed_queries: int

    # Метрики обнаружения CVE
    cves_found: List[str]
    cves_missed: List[str]

    # Точность/полнота
    true_positives: int
    false_positives: int
    false_negatives: int

    # Качество гипотез
    confirmed_hypotheses: int
    rejected_hypotheses: int
    inconclusive_hypotheses: int

    # Вычисляемые метрики
    @property
    def detection_rate(self) -> float: ...
    @property
    def precision(self) -> float: ...
    @property
    def recall(self) -> float: ...
    @property
    def f1_score(self) -> float: ...

from src.security.hypothesis import get_knowledge_base

kb = get_knowledge_base()

# Получение записи CWE {#get-cwe-entry}
cwe = kb.get_cwe("CWE-120")
print(f"Название: {cwe.name}")
print(f"Серьёзность: {cwe.severity}")
print(f"CVSS: {cwe.cvss_base}")

# Получение по категории {#get-by-category}
memory_cwes = kb.get_cwes_by_category("memory")

# Получение связанных CAPEC {#get-related-capecs}
capecs = kb.get_capecs_for_cwe("CWE-120")

# Получение паттернов для C {#get-c-patterns}
c_patterns = kb.get_language_patterns("C")

for pattern in c_patterns:
    print(f"Категория: {pattern.category}")
    print(f"Приёмники: {pattern.sinks}")
    print(f"Источники: {pattern.sources}")
    print(f"Санитайзеры: {pattern.sanitizers}")

from src.security.hypothesis import (
    HypothesisGenerator,
    MultiCriteriaScorer,
    QuerySynthesizer,
    HypothesisExecutor,
    HypothesisValidator,
    CodebaseStats
)
import duckdb

# 1. Подключение к CPG {#1-connect-to-cpg}
conn = duckdb.connect("cpg.duckdb")

# 2. Сбор статистики по кодовой базе {#2-gather-codebase-statistics}
stats = CodebaseStats(
    total_methods=conn.execute("SELECT COUNT(*) FROM nodes_method").fetchone()[0],
    total_calls=conn.execute("SELECT COUNT(*) FROM nodes_call").fetchone()[0]
)

# 3. Генерация гипотез {#3-generate-hypotheses}
generator = HypothesisGenerator()
hypotheses = generator.generate(language="C", max_hypotheses=100)

# 4. Оценка и приоритизация {#4-score-and-prioritize}
scorer = MultiCriteriaScorer()
scored = scorer.score_batch(hypotheses, stats)

# 5. Генерация SQL-запросов {#5-synthesize-sql-queries}
synthesizer = QuerySynthesizer()
for h in scored:
    h.sql_query = synthesizer.synthesize_query(h)

# 6. Выполнение запросов к CPG {#6-execute-against-cpg}
executor = HypothesisExecutor(conn)
for h in scored[:20]:  # Топ-20
    evidence = executor.execute(h)
    h.evidence.extend(evidence)

# 7. Проверка и отчёт {#7-validate-and-report}
validator = HypothesisValidator()
results = validator.validate_batch(scored)

print(f"Частота обнаружения: {results.detection_rate:.1%}")
print(f"Точность: {results.precision:.1%}")
print(f"Полнота: {results.recall:.1%}")
print(f"F1-мера: {results.f1_score:.2f}")