┌──────────────────┐
                    │   Точка входа    │
                    │  (Запрос польз.) │
                    └────────┬─────────┘
                             │
                    ┌────────▼─────────┐
                    │  Классификация   │
                    │  (Ключ. + LLM)  │
                    └────────┬─────────┘
                             │
                    ┌────────▼─────────┐
                    │  Маршрутизатор   │
                    │ (21 сценарий)   │
                    └────────┬─────────┘
                             │
              ┌──────────────┼──────────────┐
              │              │              │
     ┌────────▼───┐  ┌──────▼─────┐  ┌────▼────────┐
     │Безопасность│  │  Онбординг │  │ Произв./... │
     │  Workflow  │  │  Workflow  │  │  Workflows  │
     └────────┬───┘  └──────┬─────┘  └────┬────────┘
              │              │              │
              └──────────────┼──────────────┘
                             │
                    ┌────────▼─────────┐
                    │    Результат     │
                    │  (Ответ +        │
                    │   Доказательства)│
                    └──────────────────┘

from src.workflow import MultiScenarioCopilot

copilot = MultiScenarioCopilot()

# Автоматическое определение сценария по запросу
result = copilot.run("Найти SQL-инъекции")

# Принудительный выбор сценария
result = copilot.run(
    "Проанализировать модуль",
    context={"scenario_id": "scenario_2"}
)

# Структура результата
{
    'query': 'Найти SQL-инъекции',
    'intent': 'security_audit',
    'scenario_id': 'scenario_2',
    'confidence': 0.92,
    'answer': 'Обнаружено 3 потенциальных SQL-инъекции...',
    'evidence': ['Функция exec_simple_query в строке 142...'],
    'metadata': {...}
}

from typing import Any, Dict, List, Optional, TypedDict

class MultiScenarioState(TypedDict):
    # Входные данные
    query: str
    context: Optional[Dict[str, Any]]
    language: Optional[str]               # "en" или "ru"

    # Классификация намерений
    intent: Optional[str]                 # напр., "security_audit"
    scenario_id: Optional[str]            # напр., "scenario_2"
    confidence: Optional[float]           # 0.0–1.0
    classification_method: Optional[str]  # "keyword" или "llm"

    # Данные CPG
    cpg_results: Optional[List[Dict]]
    subsystems: Optional[List[str]]
    methods: Optional[List[Dict]]
    call_graph: Optional[Any]

    # Выходные данные
    answer: Optional[str]
    evidence: Optional[List[str]]
    metadata: Optional[Dict[str, Any]]
    retrieved_functions: Optional[List[str]]

    # Обработка ошибок
    error: Optional[str]
    retry_count: int

    # Конфигурация рабочего процесса
    enrichment_config: Optional[Dict[str, Any]]
    vector_store: Optional[Any]

from src.workflow.state import create_initial_state

state = create_initial_state(
    query="Найти утечки памяти",
    language="ru",
    context={"subsystem": "executor"}
)

from src.workflow.orchestration import classify_intent_node

# Вызывается внутренне графом
state = classify_intent_node(state)
# Заполняет: state['intent'], state['scenario_id'], state['confidence']

from src.workflow.orchestration import route_by_intent

# Возвращает имя узла сценария
next_node = route_by_intent(state)
# напр., "security_workflow", "onboarding_workflow"

src/workflow/scenarios/
├── _base/                    # Базовый класс обработчика
│   └── handler.py            # BaseHandler
├── _intent/                  # Классификация намерений
├── security/                 # Сценарий безопасности
│   ├── handlers/
│   ├── formatters/
│   └── __init__.py
├── onboarding/               # Сценарий онбординга
│   ├── handlers/
│   └── __init__.py
├── architecture_handlers/    # Сценарий архитектуры
│   ├── handlers/
│   ├── formatters/
│   └── __init__.py
├── performance_handlers/     # Сценарий производительности
├── refactoring_handlers/     # Сценарий рефакторинга
├── code_review_handlers/     # Сценарий проверка кода
├── compliance_handlers/      # Сценарий соответствия требованиям
├── documentation_handlers/   # Сценарий документации
├── tech_debt_handlers/       # Сценарий техдолга
├── debugging_handlers/       # Сценарий отладки
├── concurrency_handlers/     # Сценарий параллелизма
├── coverage_handlers/        # Сценарий покрытия тестами
├── cross_repo_handlers/      # Сценарий кросс-репо
├── feature_dev_handlers/     # Сценарий разработки функций
├── audit_composite.py        # Аудит (запускает 9 подсценариев)
├── code_optimization.py      # Оптимизация кода
├── file_editing.py           # Редактирование файлов
├── pattern_search_handlers/  # Сценарий поиска структурных шаблонов
│   ├── handlers/
│   └── __init__.py
├── standards_check.py        # Проверка стандартов
└── dependencies_analysis.py  # Анализ зависимостей

from src.workflow.scenarios._base.handler import BaseHandler
from src.workflow.scenarios._base.handler import HandlerResult

class MyHandler(BaseHandler):
    async def handle(self) -> HandlerResult:
        # self.cpg   — экземпляр CPGQueryService
        # self.state  — словарь MultiScenarioState
        # self.cfg    — унифицированная конфигурация
        # self.query  — исходный запрос
        # self.language — "en" или "ru"
        results = self.cpg.get_methods_by_subsystem("executor")
        return HandlerResult(
            answer="Найдены методы...",
            evidence=results,
            metadata={"handler": "my_handler"}
        )

python -m src.cli audit --db PATH [--language ru] [--format json]

# Встроено в граф — настраивается через state['retry_count']
# По умолчанию: до 2 повторных попыток с адаптивным уточнением запроса

# Автоматическая цепочка запасных вариантов:
# 1. SQL-запрос, сгенерированный LLM
# 2. Запрос по шаблону из примеров
# 3. Прямой вызов метода CPG

from langgraph.graph import StateGraph
from src.workflow.state import MultiScenarioState

def create_custom_workflow():
    workflow = StateGraph(MultiScenarioState)

    workflow.add_node("analyze", my_analyze_node)
    workflow.add_node("process", my_process_node)
    workflow.add_node("interpret", my_interpret_node)

    workflow.add_edge("analyze", "process")
    workflow.add_edge("process", "interpret")

    workflow.set_entry_point("analyze")
    workflow.set_finish_point("interpret")

    return workflow.compile()

result = create_custom_workflow().invoke({"query": "..."})

def route_by_intent(state: MultiScenarioState) -> str:
    if state["intent"] == "find_vulnerabilities":
        return "security_node"
    elif state["intent"] == "find_performance":
        return "performance_node"
    else:
        return "general_node"

workflow.add_conditional_edges(
    "analyze",
    route_by_intent,
    {
        "security_node": "security",
        "performance_node": "performance",
        "general_node": "general"
    }
)

copilot = MultiScenarioCopilot()

# Потоковая передача обрабатывается на уровне API/TUI
# См. src/api/routers/ для WebSocket-потоков
# См. src/tui/ для терминальных потоков