wflow.py

#!/usr/bin/env python3
"""
wflow - Workflow Runner

Запускает workflow из YAML файлов с гарантированным выполнением шагов.
Использует iFlow SDK для взаимодействия с iFlow CLI.

Переменные окружения (можно задать в .env файле):
    WFLOW_PROJECT_ROOT   - Корневая директория проекта (по умолчанию cwd)
    WFLOW_WORKFLOWS_DIR  - Директория с workflow файлами
    WFLOW_PROMPTS_DIR    - Директория с файлами промптов
    WFLOW_RUNNER_DIR     - Директория установки runner (определяется автоматически)

Usage:
    python wflow.py                     # Интерактивный режим
    python wflow.py workflow.yaml -i key=value
    python wflow.py workflows/code-review.yaml -i branch=feature/my-feature
"""

# =============================================================================
# Bootstrap: Автоматическое переключение на venv если нужно
# =============================================================================
import os
import sys
from pathlib import Path

# Определяем директорию runner
_RUNNER_DIR = Path(__file__).parent.resolve()

# Ищем venv (пробуем оба варианта: .venv и venv)
_VENV_DIR = None
for venv_name in (".venv", "venv"):
    candidate = _RUNNER_DIR / venv_name
    if candidate.exists():
        _VENV_DIR = candidate
        break

# Если запущен не из venv, и venv существует — перезапускаем из venv
if _VENV_DIR and not sys.prefix.startswith(str(_VENV_DIR)):
    _VENV_PYTHON = _VENV_DIR / "bin" / "python3"
    if _VENV_PYTHON.exists():
        import subprocess
        result = subprocess.run([str(_VENV_PYTHON), __file__] + sys.argv[1:])
        sys.exit(result.returncode)

# =============================================================================
# Основной код
# =============================================================================
import argparse
import asyncio
import json
import logging
import re
import socket
import subprocess
import time
from datetime import datetime
from typing import Any

import yaml
from rich.console import Console
from rich.markdown import Markdown
from rich.panel import Panel
from rich.table import Table

# Rich console для красивого вывода
console = Console()

# Logger для отладки
logger = logging.getLogger(__name__)

# =============================================================================
# ACP Server Check
# =============================================================================

def check_acp_server(host: str = "localhost", port: int = 8090, timeout: float = 2.0) -> bool:
    """Проверяет, запущен ли ACP сервер на указанном порту.
    
    Args:
        host: Хост для проверки
        port: Порт для проверки
        timeout: Таймаут подключения в секундах
    
    Returns:
        True если сервер доступен, False иначе
    """
    try:
        with socket.create_connection((host, port), timeout=timeout):
            return True
    except OSError:
        return False


def find_acp_server(start_port: int = 8090, max_attempts: int = 10) -> int | None:
    """Ищет запущенный ACP сервер, проверяя порты.
    
    Args:
        start_port: Начальный порт для проверки
        max_attempts: Количество портов для проверки
    
    Returns:
        Номер порта если сервер найден, None иначе
    """
    for port in range(start_port, start_port + max_attempts):
        if check_acp_server("localhost", port):
            return port
    return None


def start_acp_server(port: int = 8090, timeout: float = 10.0) -> tuple[bool, int | None]:
    """Запускает ACP сервер и ждёт его готовности.
    
    Args:
        port: Порт для запуска
        timeout: Максимальное время ожидания в секундах
    
    Returns:
        Tuple (success, actual_port)
    """
    import subprocess
    import time
    
    # Проверяем, не занят ли порт
    if check_acp_server("localhost", port):
        return True, port
    
    # Запускаем iFlow
    cmd = ["iflow", "--experimental-acp", "--port", str(port)]
    logger.debug(f"Starting iFlow: {' '.join(cmd)}")
    
    try:
        process = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            stdin=subprocess.DEVNULL,
            start_new_session=True  # Отделяем от текущего процесса
        )
    except FileNotFoundError:
        return False, None
    except Exception as e:
        logger.error(f"Failed to start iFlow: {e}")
        return False, None
    
    # Ждём готовности с информативным выводом
    start_time = time.time()
    check_interval = 0.5
    
    while time.time() - start_time < timeout:
        if check_acp_server("localhost", port):
            return True, port
        
        # Проверяем, не упал ли процесс
        if process.poll() is not None:
            return False, None
        
        time.sleep(check_interval)
    
    # Таймаут
    process.terminate()
    return False, None


def ensure_acp_server(auto_start: bool = True, preferred_port: int = 8090) -> tuple[int | None, bool]:
    """Проверяет и при необходимости запускает ACP сервер.
    
    Args:
        auto_start: Запускать сервер если не найден
        preferred_port: Предпочитаемый порт
    
    Returns:
        Tuple (port, was_started) - порт и был ли сервер запущен этим вызовом
    """
    # Сначала ищем уже запущенный сервер
    existing_port = find_acp_server(preferred_port)
    if existing_port:
        return existing_port, False
    
    if not auto_start:
        return None, False
    
    # Запускаем сервер
    success, port = start_acp_server(preferred_port)
    if success:
        return port, True
    
    return None, False

# Загружаем .env файлы
try:
    from dotenv import load_dotenv
    DOTENV_AVAILABLE = True
except ImportError:
    DOTENV_AVAILABLE = False

try:
    from iflow_sdk import IFlowClient, IFlowOptions, ApprovalMode, ErrorMessage
    from iflow_sdk.types import (
        AssistantMessage, TaskFinishMessage,
        ToolCallMessage, ToolResultMessage, PlanMessage,
        ToolConfirmationRequestMessage
    )
except ImportError:
    print("Error: iflow-cli-sdk not installed")
    print("Install: pip install iflow-cli-sdk")
    sys.exit(1)

# Применяем патчи SDK (добавляет поддержку _iflow/user/questions)
import sdk_patches
from sdk_patches import UserQuestionsMessage


# =============================================================================
# Конфигурация через переменные окружения
# =============================================================================

class Config:
    """Конфигурация runner из переменных окружения."""
    
    # Директория установки runner (где лежит этот скрипт)
    RUNNER_DIR: Path = Path(__file__).parent.resolve()
    
    # ACP сервер
    ACP_HOST: str = "localhost"
    ACP_PORT: int = 8090
    ACP_AUTO_START: bool = False  # Не автостартовать iFlow
    
    @classmethod
    def load(cls, project_dir: Path | None = None):
        """Загружает конфигурацию из .env файлов и переменных окружения."""
        
        # Определяем project root
        cls.PROJECT_ROOT = Path(
            os.getenv("WFLOW_PROJECT_ROOT", "") or 
            str(project_dir or Path.cwd())
        ).resolve()
        
        # Загружаем .env из проекта (приоритет)
        project_env = cls.PROJECT_ROOT / ".env"
        if DOTENV_AVAILABLE and project_env.exists():
            load_dotenv(project_env, override=True)
        
        # Загружаем .env из runner (значения по умолчанию)
        runner_env = cls.RUNNER_DIR / ".env"
        if DOTENV_AVAILABLE and runner_env.exists():
            load_dotenv(runner_env, override=False)
        
        # Директория с workflows
        cls.WORKFLOWS_DIR = cls._resolve_path(
            os.getenv("WFLOW_WORKFLOWS_DIR"),
            [cls.PROJECT_ROOT / ".wflow" / "workflows", cls.RUNNER_DIR / "workflows"]
        )
        
        # Директория с prompts
        cls.PROMPTS_DIR = cls._resolve_path(
            os.getenv("WFLOW_PROMPTS_DIR"),
            [cls.PROJECT_ROOT / ".wflow" / "prompts", cls.RUNNER_DIR / "prompts"]
        )
        
        # ACP сервер
        cls.ACP_HOST = os.getenv("WFLOW_ACP_HOST", "localhost")
        cls.ACP_PORT = int(os.getenv("WFLOW_ACP_PORT", "8090"))
        cls.ACP_AUTO_START = os.getenv("WFLOW_ACP_AUTO_START", "true").lower() in ("true", "1", "yes")
        
        # Переопределяем PROJECT_ROOT если изменился в .env
        cls.PROJECT_ROOT = Path(
            os.getenv("WFLOW_PROJECT_ROOT", str(cls.PROJECT_ROOT))
        ).resolve()
    
    @classmethod
    def _resolve_path(cls, env_value: str | None, fallbacks: list[Path]) -> Path:
        """Разрешает путь из переменной окружения или fallback-ов."""
        if env_value:
            path = Path(env_value)
            if path.is_absolute():
                return path
            return (cls.PROJECT_ROOT / path).resolve()
        
        for fallback in fallbacks:
            if fallback.exists():
                return fallback
        
        return fallbacks[-1]
    
    @classmethod
    def info(cls) -> str:
        """Возвращает информацию о конфигурации."""
        acp_status = "running" if check_acp_server(cls.ACP_HOST, cls.ACP_PORT) else "not running"
        return f"""
Configuration:
  PROJECT_ROOT:   {cls.PROJECT_ROOT}
  WORKFLOWS_DIR:  {cls.WORKFLOWS_DIR}
  PROMPTS_DIR:    {cls.PROMPTS_DIR}
  RUNNER_DIR:     {cls.RUNNER_DIR}

ACP Server:
  Host:           {cls.ACP_HOST}
  Port:           {cls.ACP_PORT}
  Status:         {acp_status}
  Auto-start:     {cls.ACP_AUTO_START}
"""


class WorkflowRunner:
    """Исполнитель workflow с гарантированным порядком шагов."""

    def __init__(self, workflow_path: str, verbose: bool = False, debug: bool = False):
        self.verbose = verbose
        self.debug = debug
        
        # Разрешаем путь к workflow
        self.workflow_path = self._resolve_workflow_path(workflow_path)
        self.workflow = self._load_workflow()
        
        # Состояние выполнения
        self.state: dict[str, Any] = {}
        self.context: dict[str, Any] = {}
        self.failed = False
        self.error_message: str | None = None

    def _resolve_workflow_path(self, workflow_path: str) -> Path:
        """Разрешает путь к workflow файлу."""
        path = Path(workflow_path)
        
        if path.is_absolute():
            if path.exists():
                return path
            raise FileNotFoundError(f"Workflow not found: {path}")
        
        search_paths = [
            Config.PROJECT_ROOT / workflow_path,
            Config.WORKFLOWS_DIR / workflow_path,
            Config.WORKFLOWS_DIR / f"{workflow_path}.yaml"
        ]
        
        for search_path in search_paths:
            if search_path.exists():
                return search_path
        
        raise FileNotFoundError(
            f"Workflow not found: {workflow_path}\n"
            f"Searched in:\n" +
            "\n".join(f"  - {p}" for p in search_paths)
        )

    def _load_workflow(self) -> dict:
        """Загружает workflow из YAML файла."""
        with open(self.workflow_path, encoding="utf-8") as f:
            workflow = yaml.safe_load(f)
        
        if "steps" not in workflow:
            raise ValueError("Workflow must contain 'steps' section")
        
        return workflow

    def get_required_inputs(self) -> dict[str, dict]:
        """Возвращает описание требуемых inputs из workflow."""
        inputs_schema = self.workflow.get("inputs", {})
        return inputs_schema

    def _resolve_variables(self, text: str) -> str:
        """Подставляет переменные в формате ${{ var }} или ${var}."""
        if not text:
            return text
        
        all_vars = {**self.context, **self.state}
        all_vars["PROJECT_ROOT"] = str(Config.PROJECT_ROOT)
        all_vars["WORKFLOWS_DIR"] = str(Config.WORKFLOWS_DIR)
        all_vars["PROMPTS_DIR"] = str(Config.PROMPTS_DIR)
        
        def replace_full(match):
            expr = match.group(1).strip()
            
            if expr.startswith("steps."):
                parts = expr.split(".")
                if len(parts) >= 2:
                    step_name = parts[1]
                    if step_name in self.state:
                        if len(parts) == 2:
                            return str(self.state[step_name])
                        elif parts[2] == "outputs" and len(parts) >= 4:
                            field = parts[3]
                            step_result = self.state[step_name]
                            if isinstance(step_result, dict) and field in step_result:
                                return str(step_result[field])
            
            if expr.startswith("env."):
                var_name = expr[4:]
                return str(all_vars.get(var_name, ""))
            
            if expr.startswith("inputs."):
                var_name = expr[7:]
                return str(all_vars.get(var_name, ""))
            
            if expr.startswith("config."):
                var_name = expr[7:].upper()
                return str(all_vars.get(var_name, ""))
            
            return str(all_vars.get(expr, match.group(0)))
        
        text = re.sub(r"\$\{\{\s*([^}]+)\s*\}\}", replace_full, text)
        
        def replace_simple(match):
            var_name = match.group(1)
            return str(all_vars.get(var_name, match.group(0)))
        
        text = re.sub(r"\$\{(\w+)\}", replace_simple, text)
        
        return text

    def _load_prompt(self, step: dict) -> str:
        """Загружает промпт из строки или файла."""
        if "prompt" in step:
            return self._resolve_variables(step["prompt"])
        
        if "prompt_file" in step:
            prompt_file = step["prompt_file"]
            
            search_paths = [
                self.workflow_path.parent / prompt_file,
                Config.PROMPTS_DIR / prompt_file,
                Config.RUNNER_DIR / "prompts" / prompt_file,
            ]
            
            for path in search_paths:
                if path.exists():
                    content = path.read_text(encoding="utf-8")
                    return self._resolve_variables(content)
            
            raise FileNotFoundError(
                f"Prompt file not found: {prompt_file}\n"
                f"Searched in:\n" +
                "\n".join(f"  - {p}" for p in search_paths)
            )
        
        raise ValueError(f"Step '{step.get('name', 'unknown')}' must have 'prompt' or 'prompt_file'")

    def _build_context_for_step(self, step: dict) -> str:
        """Строит контекст из указанных переменных."""
        context_vars = step.get("context", [])
        if not context_vars:
            return ""
        
        context_parts = []
        for var_name in context_vars:
            if var_name in self.state:
                value = self.state[var_name]
                context_parts.append(f"## {var_name}\n{value}")
            elif var_name in self.context:
                context_parts.append(f"## {var_name}\n{self.context[var_name]}")
        
        return "\n\n".join(context_parts)

    def _check_dependencies(self, step: dict) -> bool:
        """Проверяет, что все зависимости выполнены."""
        deps = step.get("depends_on", [])
        for dep in deps:
            if dep not in self.state:
                return False
        return True

    def _print_step_header(self, step_name: str, step_num: int, total: int):
        """Выводит заголовок шага."""
        console.print()
        console.print(Panel(
            f"[bold blue]STEP [{step_num}/{total}]: {step_name}[/]",
            border_style="blue",
            padding=(0, 2)
        ))

    def _print_step_footer(self, step_name: str, success: bool, duration: float):
        """Выводит итог шага."""
        if success:
            console.print(f"[green]✓ SUCCESS[/] [{step_name}] ({duration:.1f}s)")
        else:
            console.print(f"[red]✗ FAILED[/] [{step_name}] ({duration:.1f}s)")

    async def _execute_step(self, client: IFlowClient, step: dict, step_num: int, total: int) -> str:
        """Выполняет один шаг workflow."""
        step_name = step.get("name", f"step_{step_num}")
        
        if not self._check_dependencies(step):
            pending_deps = [d for d in step.get("depends_on", []) if d not in self.state]
            raise RuntimeError(f"Dependencies not satisfied: {pending_deps}")
        
        # Проверяем interactive флаг - запрос подтверждения перед шагом
        if step.get("interactive"):
            self._print_step_header(step_name, step_num, total)
            print("\n⚠️  This step requires confirmation.")
            
            step_desc = step.get("description", "")
            if step_desc:
                print(f"   Description: {step_desc}")
            
            while True:
                try:
                    answer = input("\nProceed with this step? [Y/n]: ").strip().lower()
                    if answer in ("", "y", "yes", "д", "да"):
                        break
                    elif answer in ("n", "no", "н", "нет"):
                        raise RuntimeError(f"Step '{step_name}' cancelled by user")
                    else:
                        print("Please enter Y or N")
                except KeyboardInterrupt:
                    print("\nCancelled.")
                    raise RuntimeError(f"Step '{step_name}' cancelled by user")
        else:
            self._print_step_header(step_name, step_num, total)
        
        start_time = datetime.now()
        
        prompt = self._load_prompt(step)
        context_text = self._build_context_for_step(step)
        if context_text:
            prompt = f"{prompt}\n\n---\n## Context from previous steps:\n{context_text}"
        
        if self.verbose:
            print(f"\n[PROMPT]\n{prompt}\n[/PROMPT]\n")
        
        # Переопределение approval_mode для конкретного шага
        step_approval = step.get("approval")
        if step_approval:
            # Определяем режим для шага
            if step_approval.lower() == "ask":
                step_approval_mode = ApprovalMode.DEFAULT
            elif step_approval.lower() == "auto":
                step_approval_mode = ApprovalMode.AUTO_EDIT
            elif step_approval.lower() == "yolo":
                step_approval_mode = ApprovalMode.YOLO
            elif step_approval.lower() == "plan":
                step_approval_mode = ApprovalMode.PLAN
            else:
                step_approval_mode = self.global_approval_mode
            
            # Если режим отличается от текущего, нужно пересоздать клиент
            if step_approval_mode != self.global_approval_mode:
                if self.debug:
                    print(f"\n\033[33m🔒 [APPROVAL] Switching to {step_approval.upper()} for this step\033[0m")
                # Обновляем approval_mode в текущей сессии через options
                client._options.approval_mode = step_approval_mode
        
        await client.send_message(prompt)
        
        result = ""
        current_agent = None
        
        async for msg in client.receive_messages():
            # === Assistant Message (text + thinking) ===
            if isinstance(msg, AssistantMessage):
                # Показываем мысли (thinking mode)
                if msg.chunk.thought and self.debug:
                    console.print("[dim]💭 [THINKING][/]")
                    for line in msg.chunk.thought.split('\n'):
                        console.print(f"[dim]  {line}[/]")
                
                # Показываем текст ответа
                if msg.chunk.text:
                    text = msg.chunk.text
                    result += text
                    
                    # Выводим текст как Markdown (убираем лишние переносы в конце)
                    text_clean = text.rstrip('\n')
                    if text_clean:
                        console.print(Markdown(text_clean))
                
                # Показываем субагента
                if msg.agent_info and self.debug:
                    agent_id = msg.agent_info.agent_id
                    if current_agent != agent_id:
                        current_agent = agent_id
                        console.print(f"[cyan]🤖 [SUBAGENT: {agent_id}][/]")
            
            # === Tool Call ===
            elif isinstance(msg, ToolCallMessage):
                if self.debug:
                    agent_str = ""
                    if msg.agent_info:
                        agent_str = f" (by {msg.agent_info.agent_id})"
                    console.print(f"[yellow]🔧 [TOOL] {msg.tool_name}[/]{agent_str}")
                    if msg.args:
                        args_str = json.dumps(msg.args, ensure_ascii=False, indent=2)
                        for line in args_str.split('\n')[:10]:  # Limit args display
                            console.print(f"[yellow]  {line}[/]")
            
            # === Tool Result ===
            elif isinstance(msg, ToolResultMessage):
                if self.debug:
                    status = "✓" if msg.status.value == "completed" else "✗"
                    status_style = "green" if msg.status.value == "completed" else "red"
                    console.print(f"[{status_style}]📦 [RESULT] {status} {msg.tool_name}[/]")
                    if msg.content and msg.content.markdown:
                        lines = msg.content.markdown.split('\n')[:5]  # Limit result display
                        for line in lines:
                            console.print(f"[green]  {line[:100]}[/]")
            
            # === Plan Update ===
            elif isinstance(msg, PlanMessage):
                if self.debug:
                    console.print("[magenta]📋 [PLAN][/]")
                    status_icons = {"pending": "⏳", "in_progress": "▶", "completed": "✓"}
                    for entry in msg.entries[:10]:  # Limit entries display
                        icon = status_icons.get(entry.status, "•")
                        priority_str = f"[{entry.priority}]" if entry.priority else ""
                        console.print(f"[magenta]  {icon} {priority_str} {entry.content[:60]}[/]")
            
            # === Error ===
            elif isinstance(msg, ErrorMessage):
                console.print(f"[red]❌ [ERROR] {msg}[/]")
            
            # === Permission Request (Tool Confirmation) ===
            elif isinstance(msg, ToolConfirmationRequestMessage):
                console.print(Panel(
                    f"[bold]Kind:[/] {msg.tool_call.kind}\n[bold]Title:[/] {msg.tool_call.title}",
                    title="[yellow]🔐 PERMISSION REQUEST[/]",
                    border_style="yellow"
                ))
                if msg.tool_call.locations:
                    for loc in msg.tool_call.locations[:3]:
                        console.print(f"  [dim]Location:[/] {loc.path}")
                        if loc.line_start:
                            console.print(f"    [dim]Lines:[/] {loc.line_start}-{loc.line_end or loc.line_start}")
                
                console.print("\n[bold]Options:[/]")
                for i, opt in enumerate(msg.options, 1):
                    kind_display = f" [dim]({opt.kind})[/]" if opt.kind else ""
                    console.print(f"  [cyan][{i}][/][bold]{opt.name}[/]{kind_display}")
                
                # Запрашиваем выбор пользователя
                while True:
                    try:
                        choice = console.input("\n  [bold]Select option (number):[/] ").strip()
                        if choice.isdigit():
                            idx = int(choice) - 1
                            if 0 <= idx < len(msg.options):
                                selected = msg.options[idx]
                                await client.respond_to_tool_confirmation(
                                    msg.request_id, selected.option_id
                                )
                                console.print(f"[green]✓ Selected: {selected.name}[/]")
                                break
                        console.print(f"[yellow]Please enter a number from 1 to {len(msg.options)}[/]")
                    except KeyboardInterrupt:
                        await client.cancel_tool_confirmation(msg.request_id)
                        console.print("[yellow]✗ Cancelled by user[/]")
                        raise RuntimeError("Permission request cancelled by user")
            
            # === User Questions (from agent) ===
            elif isinstance(msg, UserQuestionsMessage):
                console.print()
                console.print(Panel(
                    f"[bold]Agent задаёт {len(msg.questions)} вопрос(ов):[/]",
                    title="[cyan]❓ ВОПРОСЫ[/]",
                    border_style="cyan"
                ))
                
                answers = []
                for i, q in enumerate(msg.questions, 1):
                    header = q.get("header", f"Вопрос {i}")
                    question = q.get("question", "")
                    options = q.get("options", [])
                    multi_select = q.get("multiSelect", False)
                    
                    # Разделитель между вопросами
                    if i > 1:
                        console.print()
                    console.print(f"[dim]{'─' * 60}[/]")
                    console.print(f"\n[cyan bold]❓ [{header}][/]")
                    console.print(f"[bold]{question}[/]\n")
                    
                    if options:
                        console.print("[bold]Варианты:[/]")
                        for j, opt in enumerate(options, 1):
                            label = opt.get("label", str(opt))
                            desc = opt.get("description", "")
                            if desc:
                                # Ограничиваем длину описания
                                desc_short = desc[:70] + "..." if len(desc) > 70 else desc
                                console.print(f"  [cyan bold][{j}][/][bold]{label}[/]")
                                console.print(f"      [dim]{desc_short}[/]")
                            else:
                                console.print(f"  [cyan bold][{j}][/][bold]{label}[/]")
                        
                        # Показываем опцию для произвольного ввода
                        other_num = len(options) + 1
                        console.print(f"  [yellow bold][{other_num}][/][bold]Другое...[/]")
                        console.print("      [dim]Ввести свой ответ[/]")
                        
                        if multi_select:
                            console.print("\n[dim]💡 Можно выбрать несколько через запятую: 1,2,3[/]")
                        
                        while True:
                            try:
                                prompt_text = "  [bold]Выберите вариант:[/] " if not multi_select else "  [bold]Выберите (через запятую):[/] "
                                choice = console.input(prompt_text).strip()
                                
                                if multi_select:
                                    # Парсим множественный выбор
                                    parts = [x.strip() for x in choice.split(",")]
                                    indices = []
                                    other_text = None
                                    
                                    for part in parts:
                                        if part.isdigit():
                                            idx = int(part) - 1
                                            if 0 <= idx < len(options):
                                                indices.append(idx)
                                            elif idx == len(options):  # "Other" option
                                                other_text = console.input("  [bold]Введите ответ:[/] ").strip()
                                    
                                    if indices or other_text:
                                        selected_labels = [options[idx].get("label") for idx in indices if idx < len(options)]
                                        selected_indices = [idx for idx in indices if idx < len(options)]
                                        if other_text:
                                            selected_labels.append(other_text)
                                        answers.append({
                                            "question": i - 1,
                                            "selected": selected_labels,
                                            "selectedIndices": selected_indices,  # Индексы выбранных опций
                                            "answer": ", ".join(selected_labels)
                                        })
                                        break
                                else:
                                    if choice.isdigit():
                                        idx = int(choice) - 1
                                        if 0 <= idx < len(options):
                                            answers.append({
                                                "question": i - 1,
                                                "selectedIndex": idx,  # Индекс выбранной опции
                                                "answer": options[idx].get("label", options[idx])
                                            })
                                            break
                                        elif idx == len(options):  # "Other" option
                                            other_answer = console.input("  [bold]Введите ответ:[/] ").strip()
                                            if other_answer:
                                                answers.append({
                                                    "question": i - 1,
                                                    "answer": other_answer
                                                })
                                                break
                                    
                                    # Произвольный текст как ответ
                                    if choice:
                                        answers.append({
                                            "question": i - 1,
                                            "answer": choice
                                        })
                                        break
                                
                                console.print("[yellow]Введите номер варианта или свой текст[/]")
                            except KeyboardInterrupt:
                                raise RuntimeError("Questions cancelled by user")
                    else:
                        # Свободный ввод
                        try:
                            answer = console.input("  [bold]Ответ:[/] ").strip()
                            answers.append({
                                "question": i - 1,
                                "answer": answer
                            })
                        except KeyboardInterrupt:
                            raise RuntimeError("Questions cancelled by user")
                
                # Отправляем ответы
                console.print()
                await client._protocol.respond_to_user_questions(
                    msg.request_id, 
                    answers,
                    msg.questions  # Передаём вопросы для получения header и labels
                )
                console.print("[green]✓ Ответы отправлены[/]")
            
            # === Task Finished ===
            elif isinstance(msg, TaskFinishMessage):
                console.print()
                break
        
        # Восстанавливаем глобальный approval_mode после шага
        if step_approval:
            client._options.approval_mode = self.global_approval_mode
        
        duration = (datetime.now() - start_time).total_seconds()
        self._print_step_footer(step_name, True, duration)
        
        if step.get("output_format") == "json":
            try:
                json_match = re.search(r"```(?:json)?\s*([\s\S]*?)```", result)
                if json_match:
                    result = json.loads(json_match.group(1))
                else:
                    result = json.loads(result)
            except json.JSONDecodeError:
                pass
        
        return result

    def run(self, inputs: dict[str, str]) -> dict[str, Any]:
        """Запускает workflow синхронно."""
        return asyncio.run(self._run_async(inputs))

    async def _run_async(self, inputs: dict[str, str]) -> dict[str, Any]:
        """Асинхронное выполнение workflow."""
        self.context = {
            "PROJECT_ROOT": str(Config.PROJECT_ROOT),
            "WORKFLOWS_DIR": str(Config.WORKFLOWS_DIR),
            "PROMPTS_DIR": str(Config.PROMPTS_DIR),
            **self.workflow.get("env", {}),
            **inputs
        }
        
        console.print()
        console.print(Panel(
            f"[bold blue]{self.workflow.get('name', self.workflow_path.stem)}[/]",
            border_style="blue"
        ))
        
        if self.verbose:
            console.print(Config.info())
        
        console.print("\n[bold]Inputs:[/]")
        for key, value in inputs.items():
            console.print(f"  [cyan]{key}:[/] {value}")
        
        # Проверяем и при необходимости запускаем ACP сервер
        console.print()
        acp_port, was_started = ensure_acp_server(
            auto_start=Config.ACP_AUTO_START,
            preferred_port=Config.ACP_PORT
        )
        
        if acp_port is None:
            console.print(Panel(
                f"[red bold]ACP сервер не найден и не удалось его запустить[/]\n\n"
                f"[yellow]Запустите iFlow вручную:[/]\n\n"
                f"  [cyan]iflow --experimental-acp --port {Config.ACP_PORT}[/]",
                title="[red bold]ACP SERVER ERROR[/]",
                border_style="red"
            ))
            raise RuntimeError(f"ACP server not running and auto-start failed")
        
        if was_started:
            console.print(f"[green]✓ ACP сервер запущен на порту {acp_port}[/]")
        elif acp_port != Config.ACP_PORT:
            console.print(f"[cyan]ℹ️  ACP сервер найден на порту {acp_port} (не на {Config.ACP_PORT})[/]")
        else:
            console.print(f"[dim]✓ ACP сервер уже запущен на порту {acp_port}[/]")
        
        # Default approval_mode - DEFAULT (безопаснее чем YOLO)
        approval_mode_str = self.workflow.get("approval_mode", "DEFAULT").upper()
        self.global_approval_mode = getattr(ApprovalMode, approval_mode_str, ApprovalMode.DEFAULT)
        
        options = IFlowOptions(
            url=f"ws://{Config.ACP_HOST}:{acp_port}/acp",
            file_access=True,
            file_allowed_dirs=[str(Config.PROJECT_ROOT)],
            cwd=str(Config.PROJECT_ROOT),
            timeout=self.workflow.get("timeout", 600.0),
            approval_mode=self.global_approval_mode,
            auto_start_process=False,  # Мы сами управляем запуском
        )
        
        total_steps = len(self.workflow["steps"])
        
        try:
            async with IFlowClient(options) as client:
                for i, step in enumerate(self.workflow["steps"], 1):
                    step_name = step.get("name", f"step_{i}")
                    
                    # Определяем количество попыток
                    on_failure = step.get("on_failure", {})
                    max_retries = on_failure.get("retry", 0) if isinstance(on_failure, dict) else 0
                    attempt = 0
                    
                    while True:
                        try:
                            result = await self._execute_step(client, step, i, total_steps)
                            self.state[step_name] = result
                            
                            if "on_success" in step:
                                print(f"\n[HOOK] {step['on_success']}")
                            
                            break  # Успех - выходим из цикла попыток
                        
                        except Exception as e:
                            attempt += 1
                            
                            if attempt <= max_retries:
                                print(f"\n\033[33m⚠️  [RETRY] Attempt {attempt}/{max_retries} for step '{step_name}'\033[0m")
                                if on_failure.get("notify"):
                                    print(f"\n[NOTIFY] Step '{step_name}' failed, retrying...")
                                continue  # Повторяем попытку
                            
                            # Попытки исчерпаны
                            self.failed = True
                            self.error_message = str(e)
                            
                            if isinstance(on_failure, dict) and on_failure.get("notify"):
                                print(f"\n[NOTIFY] Step failed after {max_retries} retries: {step_name}")
                            
                            raise RuntimeError(f"Step '{step_name}' failed: {e}")
        
        except Exception as e:
            console.print()
            console.print(Panel(
                f"[red bold]{e}[/]",
                title="[red bold]WORKFLOW FAILED[/]",
                border_style="red"
            ))
            raise
        
        console.print()
        console.print(Panel(
            f"[green bold]Executed {total_steps} steps[/]",
            title="[green bold]WORKFLOW COMPLETED SUCCESSFULLY[/]",
            border_style="green"
        ))
        
        return self.state


# =============================================================================
# Интерактивный режим
# =============================================================================

def list_available_workflows() -> list[Path]:
    """Возвращает список доступных workflow файлов."""
    workflows = []
    
    # Ищем в WORKFLOWS_DIR
    if Config.WORKFLOWS_DIR.exists():
        workflows.extend(Config.WORKFLOWS_DIR.glob("*.yaml"))
        workflows.extend(Config.WORKFLOWS_DIR.glob("*.yml"))
    
    # Убираем дубликаты и сортируем
    workflows = sorted(set(workflows), key=lambda p: p.stem)
    
    return workflows


def select_workflow_interactive() -> Path | None:
    """Интерактивный выбор workflow."""
    workflows = list_available_workflows()
    
    if not workflows:
        console.print("[yellow]No workflows found.[/]")
        console.print(f"\nCreate workflow files in: [cyan]{Config.WORKFLOWS_DIR}[/]")
        return None
    
    console.print()
    console.print(Panel("[bold]Available Workflows[/]", border_style="blue"))
    
    for i, wf_path in enumerate(workflows, 1):
        # Читаем название из файла
        try:
            with open(wf_path, encoding="utf-8") as f:
                wf_data = yaml.safe_load(f)
            name = wf_data.get("name", wf_path.stem)
            desc = wf_data.get("description", "")
            if desc:
                desc_display = desc[:60] + "..." if len(desc) > 60 else desc
                console.print(f"\n  [cyan][{i}][/][bold]{wf_path.stem}[/]")
                console.print(f"      [dim]{name}[/]")
                console.print(f"      [dim]{desc_display}[/]")
            else:
                console.print(f"\n  [cyan][{i}][/][bold]{wf_path.stem}[/] — [dim]{name}[/]")
        except Exception:
            console.print(f"\n  [cyan][{i}][/][bold]{wf_path.stem}[/]")
    
    console.print()
    
    while True:
        try:
            choice = console.input("[bold]Select workflow (number or name):[/] ").strip()
            
            if not choice:
                console.print("[yellow]Cancelled.[/]")
                return None
            
            # Проверяем по номеру
            if choice.isdigit():
                idx = int(choice) - 1
                if 0 <= idx < len(workflows):
                    return workflows[idx]
                console.print(f"[yellow]Invalid number. Choose 1-{len(workflows)}[/]")
                continue
            
            # Проверяем по имени
            for wf_path in workflows:
                if wf_path.stem.lower() == choice.lower():
                    return wf_path
            
            console.print(f"[yellow]Workflow '{choice}' not found[/]")
            
        except KeyboardInterrupt:
            console.print("\n[yellow]Cancelled.[/]")
            return None


def collect_inputs_interactive(workflow: dict) -> dict[str, str]:
    """Интерактивный сбор inputs для workflow."""
    inputs_schema = workflow.get("inputs", {})
    inputs = {}
    
    if not inputs_schema:
        console.print("\n[dim]No inputs required for this workflow.[/]")
        return inputs
    
    console.print()
    console.print(Panel("[bold]Workflow Inputs[/]", border_style="blue"))
    
    for input_name, input_spec in inputs_schema.items():
        # input_spec может быть строкой (просто описание) или dict
        if isinstance(input_spec, str):
            description = input_spec
            required = True
            default = None
            example = None
        else:
            description = input_spec.get("description", input_name)
            required = input_spec.get("required", True)
            default = input_spec.get("default")
            example = input_spec.get("example")
        
        # Формируем подсказку
        console.print(f"\n  [cyan]{input_name}:[/] {description}")
        
        if example:
            console.print(f"      [dim]Example: {example}[/]")
        
        if default is not None:
            console.print(f"      [dim]Default: {default}[/]")
        
        if not required:
            console.print("      [dim](optional)[/]")
        
        # Запрашиваем ввод
        while True:
            try:
                prompt = f"    [bold]> {input_name}[/]"
                if default is not None:
                    prompt += f" [{default}]: "
                else:
                    prompt += ": "
                
                value = console.input(prompt).strip()
                
                if not value:
                    if default is not None:
                        value = str(default)
                    elif required:
                        console.print("      [yellow]This field is required.[/]")
                        continue
                    else:
                        value = ""
                
                inputs[input_name] = value
                break
                
            except KeyboardInterrupt:
                console.print("\n\n[yellow]Cancelled.[/]")
                sys.exit(0)
    
    return inputs


def confirm_execution(workflow: dict, inputs: dict[str, str]) -> bool:
    """Подтверждение запуска workflow."""
    console.print()
    console.print(Panel("[bold]Ready to Execute[/]", border_style="green"))
    
    console.print(f"\n  [cyan]Workflow:[/] {workflow.get('name', 'N/A')}")
    console.print(f"  [cyan]Steps:[/] {len(workflow.get('steps', []))}")
    
    if inputs:
        console.print("\n  [bold]Inputs:[/]")
        for key, value in inputs.items():
            # Обрезаем длинные значения
            display_val = value if len(value) <= 50 else value[:47] + "..."
            console.print(f"    [cyan]{key}:[/] {display_val}")
    
    console.print()
    
    while True:
        try:
            answer = console.input("[bold]Proceed? [Y/n]:[/] ").strip().lower()
            return answer in ("", "y", "yes", "д", "да")
        except KeyboardInterrupt:
            console.print("\n[yellow]Cancelled.[/]")
            return False


# =============================================================================
# CLI
# =============================================================================

def parse_input(value: str) -> tuple[str, str]:
    """Парсит input в формате key=value."""
    if "=" not in value:
        raise argparse.ArgumentTypeError(f"Invalid input format: {value}. Expected key=value")
    key, val = value.split("=", 1)
    return key.strip(), val.strip()


def main():
    parser = argparse.ArgumentParser(
        description="wflow - Workflow Runner",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Environment Variables:
  WFLOW_PROJECT_ROOT    Project root directory (default: cwd)
  WFLOW_WORKFLOWS_DIR   Directory with workflow files
  WFLOW_PROMPTS_DIR     Directory with prompt files

Examples:
  # Интерактивный режим (выбор workflow и ввод параметров)
  python wflow.py

  # Запуск workflow по имени
  python wflow.py demo -i name=test

  # Запуск с полным путём
  python wflow.py workflows/code-review.yaml -i branch=feature/my-feature

  # Показать конфигурацию
  python wflow.py --info
        """
    )
    
    parser.add_argument(
        "workflow",
        nargs="?",
        help="Path or name of workflow YAML file (interactive if not specified)"
    )
    
    parser.add_argument(
        "-i", "--input",
        action="append",
        type=parse_input,
        default=[],
        metavar="KEY=VALUE",
        help="Input variable for workflow (can be used multiple times)"
    )
    
    parser.add_argument(
        "-v", "--verbose",
        action="store_true",
        help="Show detailed output including prompts"
    )
    
    parser.add_argument(
        "-d", "--debug",
        action="store_true",
        help="Show agent process: thinking, tool calls, subagents, planning"
    )
    
    parser.add_argument(
        "--dry-run",
        action="store_true",
        help="Parse and validate workflow without executing"
    )
    
    parser.add_argument(
        "--info",
        action="store_true",
        help="Show configuration and exit"
    )
    
    parser.add_argument(
        "-C", "--directory",
        type=Path,
        help="Run as if started in this directory"
    )
    
    parser.add_argument(
        "-y", "--yes",
        action="store_true",
        help="Skip confirmation prompt"
    )
    
    parser.add_argument(
        "--exit-code",
        action="store_true",
        help="Output only exit code (0=success, 1=error, 2=acp not running). Useful for pipelines"
    )
    
    parser.add_argument(
        "--check-acp",
        action="store_true",
        help="Check if ACP server is running and exit with appropriate code"
    )
    
    args = parser.parse_args()
    
    # Загружаем конфигурацию
    project_dir = args.directory if args.directory else None
    Config.load(project_dir)
    
    # Exit codes для pipeline:
    # 0 = success
    # 1 = workflow error
    # 2 = ACP server not running
    EXIT_SUCCESS = 0
    EXIT_ERROR = 1
    EXIT_ACP_NOT_RUNNING = 2
    
    # --check-acp - проверка ACP сервера
    if args.check_acp:
        acp_port = find_acp_server(Config.ACP_PORT)
        if args.exit_code:
            # Для pipeline - просто выводим порт или nothing
            if acp_port:
                print(acp_port)
                return EXIT_SUCCESS
            else:
                return EXIT_ACP_NOT_RUNNING
        else:
            # Обычный вывод
            if acp_port:
                console.print(f"[green]✓ ACP server running on port {acp_port}[/]")
                return EXIT_SUCCESS
            else:
                console.print(f"[red]✗ ACP server not found on port {Config.ACP_PORT}[/]")
                console.print(f"\n[yellow]Start iFlow with:[/] iflow --experimental-acp --port {Config.ACP_PORT}")
                return EXIT_ACP_NOT_RUNNING
    
    # --info - показать конфигурацию
    if args.info:
        console.print(Config.info())
        return EXIT_SUCCESS
    
    # Интерактивный выбор workflow если не указан
    if not args.workflow:
        if args.exit_code:
            print("Error: workflow required in --exit-code mode", file=sys.stderr)
            return EXIT_ERROR
            
        console.print()
        console.print(Panel("[bold blue]wflow - Workflow Runner[/]", border_style="blue"))
        console.print(Config.info())
        
        workflow_path = select_workflow_interactive()
        if not workflow_path:
            return EXIT_ERROR
    else:
        try:
            runner = WorkflowRunner(args.workflow, verbose=args.verbose, debug=args.debug)
            workflow_path = runner.workflow_path
        except Exception as e:
            if args.exit_code:
                print(f"Error: {e}", file=sys.stderr)
                return EXIT_ERROR
            console.print(f"[red]Error loading workflow: {e}[/]")
            return EXIT_ERROR
    
    # Загружаем workflow
    try:
        runner = WorkflowRunner(str(workflow_path), verbose=args.verbose, debug=args.debug)
    except Exception as e:
        if args.exit_code:
            print(f"Error: {e}", file=sys.stderr)
            return EXIT_ERROR
        console.print(f"[red]Error loading workflow: {e}[/]")
        return EXIT_ERROR
    
    # Собираем inputs
    cli_inputs = dict(args.input)
    
    # Если есть CLI inputs - используем их
    # Если нет - запрашиваем интерактивно
    if cli_inputs:
        inputs = cli_inputs
    else:
        if args.exit_code:
            # В pipeline режиме все inputs должны быть переданы через -i
            required = runner.get_required_inputs()
            if required:
                missing = [k for k, v in required.items() 
                          if isinstance(v, dict) and v.get("required", True) or isinstance(v, str)]
                if missing:
                    print(f"Error: missing required inputs: {', '.join(missing)}", file=sys.stderr)
                    return EXIT_ERROR
            inputs = {}
        else:
            inputs = collect_inputs_interactive(runner.workflow)
    
    # Dry run
    if args.dry_run:
        console.print("\n[green]Workflow loaded successfully![/]")
        console.print(f"[cyan]Name:[/] {runner.workflow.get('name', 'N/A')}")
        console.print(f"[cyan]File:[/] {runner.workflow_path}")
        console.print(f"[cyan]Steps:[/] {len(runner.workflow.get('steps', []))}")
        for i, step in enumerate(runner.workflow.get("steps", []), 1):
            console.print(f"  [dim]{i}.[/] {step.get('name', 'unnamed')}")
        return EXIT_SUCCESS
    
    # Подтверждение (если не -y)
    if not args.yes and not args.workflow and not args.exit_code:
        if not confirm_execution(runner.workflow, inputs):
            return EXIT_SUCCESS
    
    # Запускаем
    try:
        runner.run(inputs)
        return EXIT_SUCCESS
    except RuntimeError as e:
        if args.exit_code:
            print(f"Error: {e}", file=sys.stderr)
        # Проверяем, связана ли ошибка с ACP
        if "ACP" in str(e) or "server not running" in str(e).lower():
            return EXIT_ACP_NOT_RUNNING
        return EXIT_ERROR
    except Exception as e:
        if args.exit_code:
            print(f"Error: {e}", file=sys.stderr)
        else:
            console.print(f"[red]Unexpected error: {e}[/]")
        return EXIT_ERROR


if __name__ == "__main__":
    sys.exit(main())