cloudshellgpt 1.0.0__py3-none-any.whl

cloudshellgpt/formatter.py

@@ -0,0 +1,328 @@
+"""Output formatter — renders results in multiple formats (table, json, yaml, csv).
+
+Supports TTY auto-detection, Rich panels/progress, and multi-format output.
+When stdout is not a TTY (piped), outputs plain JSON without colors.
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import sys
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any, Literal
+
+import yaml
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+from rich.text import Text
+
+from cloudshellgpt.executor import ExecutionResult
+
+FormatType = Literal["table", "json", "yaml", "csv", "raw"]
+
+# ---------------------------------------------------------------------------
+# Mensajes de error en español (humanizados)
+# ---------------------------------------------------------------------------
+
+ERROR_MESSAGES: dict[str, str] = {
+    "command_failed": "El comando falló con código de salida {exit_code}",
+    "command_failed_detail": "Detalle: {error}",
+    "stderr_output": "Salida de error del proceso:",
+    "suggestion_check_credentials": (
+        "Sugerencia: Verifica tus credenciales de AWS y permisos IAM."
+    ),
+    "suggestion_check_syntax": (
+        "Sugerencia: Revisa la sintaxis del comando o ejecuta con --dry-run primero."
+    ),
+    "suggestion_check_region": ("Sugerencia: Confirma que la región configurada es correcta."),
+    "dry_run_label": "Simulación (dry-run)",
+    "executed_label": "Ejecutado",
+    "duration_label": "Duración",
+    "command_label": "Comando",
+    "executing_label": "Ejecutando comando AWS...",
+}
+
+
+# ---------------------------------------------------------------------------
+# Formatter
+# ---------------------------------------------------------------------------
+
+
+class Formatter:
+    """Formats execution results for human or machine consumption.
+
+    Auto-detects whether stdout is a TTY. When piped (no TTY), outputs plain
+    JSON without Rich formatting or colors to support scripting workflows.
+
+    Args:
+        format_type: Output format to use (table, json, yaml, csv, raw).
+        force_tty: Override TTY detection (useful for testing).
+    """
+
+    def __init__(
+        self,
+        format_type: FormatType = "table",
+        force_tty: bool | None = None,
+    ) -> None:
+        self.format_type = format_type
+        self._is_tty = force_tty if force_tty is not None else sys.stdout.isatty()
+        self.console = Console(
+            force_terminal=self._is_tty,
+            no_color=not self._is_tty,
+        )
+
+    @property
+    def is_tty(self) -> bool:
+        """Whether the output is going to an interactive terminal."""
+        return self._is_tty
+
+    def render(self, result: ExecutionResult) -> None:
+        """Render an ExecutionResult in the configured format.
+
+        When not a TTY, always outputs plain JSON regardless of configured format.
+
+        Args:
+            result: The execution result to format.
+        """
+        if not self._is_tty:
+            self._render_plain_json(result)
+            return
+
+        if result.exit_code != 0:
+            self._render_error(result)
+            return
+
+        formatter = {
+            "table": self._render_table,
+            "json": self._render_json,
+            "yaml": self._render_yaml,
+            "csv": self._render_csv,
+            "raw": self._render_raw,
+        }.get(self.format_type, self._render_table)
+
+        formatter(result)
+
+    @contextmanager
+    def progress_spinner(self, message: str | None = None) -> Generator[None, None, None]:
+        """Context manager that shows a Rich spinner while work is in progress.
+
+        Only displays the spinner when output is a TTY. In non-TTY mode,
+        this is a no-op to avoid polluting piped output.
+
+        Args:
+            message: Optional message to display alongside the spinner.
+
+        Yields:
+            None — use as a context manager around long-running operations.
+        """
+        label = message or ERROR_MESSAGES["executing_label"]
+
+        if not self._is_tty:
+            yield
+            return
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[bold blue]{task.description}"),
+            console=self.console,
+            transient=True,
+        ) as progress:
+            progress.add_task(label, total=None)
+            yield
+
+    # ------------------------------------------------------------------
+    # TTY renderers (Rich formatting)
+    # ------------------------------------------------------------------
+
+    def _render_table(self, result: ExecutionResult) -> None:
+        """Render as a Rich table wrapped in an info panel."""
+        parsed = self._try_parse_json(result.stdout)
+
+        if isinstance(parsed, list) and parsed:
+            first = parsed[0]
+            if isinstance(first, dict):
+                table = Table(show_header=True, header_style="bold cyan")
+                for key in first.keys():
+                    table.add_column(str(key))
+
+                for item in parsed[:50]:
+                    row = [str(item.get(k, "")) for k in first.keys()]
+                    table.add_row(*row)
+
+                panel = self._build_info_panel(result, table)
+                self.console.print(panel)
+
+                if len(parsed) > 50:
+                    self.console.print(f"[dim]... y {len(parsed) - 50} más[/dim]")
+                return
+
+        # Fallback: wrap raw output in panel
+        panel = self._build_info_panel(result, Text(result.stdout))
+        self.console.print(panel)
+
+    def _render_json(self, result: ExecutionResult) -> None:
+        """Render as pretty-printed JSON with syntax highlighting."""
+        parsed = self._try_parse_json(result.stdout)
+        if parsed is not None:
+            self.console.print_json(json.dumps(parsed, indent=2, default=str))
+        else:
+            self.console.print(result.stdout)
+
+    def _render_yaml(self, result: ExecutionResult) -> None:
+        """Render as YAML output."""
+        parsed = self._try_parse_json(result.stdout)
+        if parsed is not None:
+            output = yaml.dump(parsed, default_flow_style=False, allow_unicode=True)
+            self.console.print(output)
+        else:
+            self.console.print(result.stdout)
+
+    def _render_csv(self, result: ExecutionResult) -> None:
+        """Render as CSV output."""
+        parsed = self._try_parse_json(result.stdout)
+        if isinstance(parsed, list) and parsed and isinstance(parsed[0], dict):
+            output = io.StringIO()
+            writer = csv.DictWriter(output, fieldnames=parsed[0].keys())
+            writer.writeheader()
+            writer.writerows(parsed)
+            self.console.print(output.getvalue())
+        else:
+            self.console.print(result.stdout)
+
+    def _render_raw(self, result: ExecutionResult) -> None:
+        """Render as plain text without extra formatting."""
+        self.console.print(result.stdout)
+
+    # ------------------------------------------------------------------
+    # Non-TTY renderer (plain JSON for piping)
+    # ------------------------------------------------------------------
+
+    def _render_plain_json(self, result: ExecutionResult) -> None:
+        """Output plain JSON without colors for non-TTY contexts (pipes, scripts).
+
+        Args:
+            result: The execution result to serialize.
+        """
+        data: dict[str, Any] = {
+            "command": result.command,
+            "exit_code": result.exit_code,
+            "duration_ms": result.duration_ms,
+            "dry_run": result.dry_run,
+        }
+
+        if result.exit_code == 0:
+            parsed = self._try_parse_json(result.stdout)
+            data["output"] = parsed if parsed is not None else result.stdout
+        else:
+            data["error"] = result.error
+            data["stderr"] = result.stderr
+
+        print(json.dumps(data, indent=2, default=str, ensure_ascii=False))
+
+    # ------------------------------------------------------------------
+    # Error rendering (Spanish, humanized)
+    # ------------------------------------------------------------------
+
+    def _render_error(self, result: ExecutionResult) -> None:
+        """Render an error result with context and suggestions in Spanish.
+
+        Args:
+            result: The failed execution result.
+        """
+        title = ERROR_MESSAGES["command_failed"].format(exit_code=result.exit_code)
+
+        error_parts: list[str] = []
+
+        if result.error:
+            error_parts.append(ERROR_MESSAGES["command_failed_detail"].format(error=result.error))
+
+        if result.stderr:
+            error_parts.append(f"\n{ERROR_MESSAGES['stderr_output']}")
+            error_parts.append(result.stderr.strip())
+
+        # Add contextual suggestion based on error content
+        suggestion = self._get_error_suggestion(result)
+        if suggestion:
+            error_parts.append(f"\n💡 {suggestion}")
+
+        body = "\n".join(error_parts) if error_parts else title
+
+        panel = Panel(
+            body,
+            title=f"[red]✗ {title}[/red]",
+            subtitle=f"[dim]{result.command}[/dim]",
+            border_style="red",
+            padding=(1, 2),
+        )
+        self.console.print(panel)
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _build_info_panel(self, result: ExecutionResult, content: Table | Text) -> Panel:
+        """Build a Rich Panel wrapping content with execution metadata.
+
+        Args:
+            result: Execution result for metadata.
+            content: The renderable content to wrap.
+
+        Returns:
+            A Rich Panel with command info.
+        """
+        status = (
+            ERROR_MESSAGES["dry_run_label"] if result.dry_run else ERROR_MESSAGES["executed_label"]
+        )
+        duration_s = result.duration_ms / 1000.0
+        subtitle = f"[dim]{ERROR_MESSAGES['duration_label']}: {duration_s:.2f}s | {status}[/dim]"
+
+        return Panel(
+            content,
+            title=f"[bold green]$ {result.command}[/bold green]",
+            subtitle=subtitle,
+            border_style="green",
+            padding=(0, 1),
+        )
+
+    def _get_error_suggestion(self, result: ExecutionResult) -> str:
+        """Return a contextual suggestion based on the error content.
+
+        Args:
+            result: The failed execution result.
+
+        Returns:
+            A suggestion string in Spanish, or empty string if no match.
+        """
+        combined = f"{result.stderr or ''} {result.error or ''}".lower()
+
+        if any(
+            kw in combined for kw in ("accessdenied", "unauthorized", "forbidden", "credentials")
+        ):
+            return ERROR_MESSAGES["suggestion_check_credentials"]
+
+        if any(kw in combined for kw in ("invalidregion", "could not connect", "endpoint")):
+            return ERROR_MESSAGES["suggestion_check_region"]
+
+        if any(kw in combined for kw in ("invalidparametervalue", "malformed", "syntax", "usage:")):
+            return ERROR_MESSAGES["suggestion_check_syntax"]
+
+        return ""
+
+    def _try_parse_json(self, text: str) -> Any:
+        """Try to parse text as JSON, return None if not valid.
+
+        Args:
+            text: Raw text to attempt JSON parsing on.
+
+        Returns:
+            Parsed JSON value, or None if parsing fails.
+        """
+        try:
+            return json.loads(text)
+        except (json.JSONDecodeError, TypeError):
+            return None

cloudshellgpt/i18n.py

@@ -0,0 +1,203 @@
+"""Internationalization — UI labels for CloudShellGPT."""
+
+from __future__ import annotations
+
+# Supported UI translations. Keys are ISO 639-1 language codes.
+# Falls back to English ("en") for unsupported languages.
+
+TRANSLATIONS: dict[str, dict[str, str]] = {
+    "en": {
+        "plan_title": "Plan",
+        "flags_title": "🔍 Command flags",
+        "tip_title": "💡 Tip",
+        "related_title": "🔗 Related commands",
+        "risk_label": "Risk",
+        "cost_label": "Cost",
+        "command_label": "Command",
+        "explanation_label": "Explanation",
+        "proceed_prompt": "Proceed?",
+        "confirm_high_title": "Confirmation Required",
+        "confirm_high_banner": "⚠️  HIGH RISK OPERATION",
+        "confirm_critical_title": "⚠️  CRITICAL WARNING",
+        "confirm_critical_banner": "🚨 CRITICAL OPERATION — IRREVERSIBLE",
+        "affected_resources": "Affected resources",
+        "estimated_cost": "Estimated cost",
+        "type_resource": 'Type the resource name ("{resource}") to confirm',
+        "type_confirm": 'Type "confirm" to proceed',
+        "type_yes_i_understand": "To proceed with this critical operation, type yes-i-understand:",
+        "dry_run_performing": "Performing dry-run...",
+        "dry_run_success": "Dry-run successful — operation would succeed",
+        "dry_run_failed": "Dry-Run Failed",
+        "dry_run_result": "Dry-Run Result",
+        "dry_run_preview": "Dry-Run Preview",
+        "cancelled": "Cancelled.",
+        "confirmation_mismatch": "Confirmation did not match. Cancelled.",
+        "cost_unavailable": "⚠️  Cost estimation unavailable — proceed with caution",
+        "cost_preview_title": "Cost Preview",
+        "execution_success": "Executed",
+        "execution_failed": "Command failed with exit code {code}",
+        "execution_duration": "Duration: {duration}s",
+        "error_detail": "Detail",
+        "error_suggestion": "Suggestion: Check your AWS credentials and IAM permissions.",
+        "could_not_understand": "Could not understand: {intent}",
+        "did_you_mean": "Try being more specific. Example: 'list the S3 buckets' or 'create a new EC2 instance t3.micro'",
+    },
+    "es": {
+        "plan_title": "Plan",
+        "flags_title": "🔍 Flags del comando",
+        "tip_title": "💡 Consejo",
+        "related_title": "🔗 Comandos relacionados",
+        "risk_label": "Riesgo",
+        "cost_label": "Costo",
+        "command_label": "Comando",
+        "explanation_label": "Explicación",
+        "proceed_prompt": "¿Ejecutar?",
+        "confirm_high_title": "Confirmación requerida",
+        "confirm_high_banner": "⚠️  OPERACIÓN DE ALTO RIESGO",
+        "confirm_critical_title": "⚠️  ADVERTENCIA CRÍTICA",
+        "confirm_critical_banner": "🚨 OPERACIÓN CRÍTICA — IRREVERSIBLE",
+        "affected_resources": "Recursos afectados",
+        "estimated_cost": "Costo estimado",
+        "type_resource": 'Escribe el nombre del recurso ("{resource}") para confirmar',
+        "type_confirm": 'Escribe "confirm" para proceder',
+        "type_yes_i_understand": "Para continuar con esta operación crítica, escribe yes-i-understand:",
+        "dry_run_performing": "Ejecutando dry-run...",
+        "dry_run_success": "Dry-run exitoso — la operación sería exitosa",
+        "dry_run_failed": "Dry-Run fallido",
+        "dry_run_result": "Resultado Dry-Run",
+        "dry_run_preview": "Vista previa Dry-Run",
+        "cancelled": "Cancelado.",
+        "confirmation_mismatch": "La confirmación no coincide. Cancelado.",
+        "cost_unavailable": "⚠️  Estimación de costos no disponible — proceder con precaución",
+        "cost_preview_title": "Vista previa de costos",
+        "execution_success": "Ejecutado",
+        "execution_failed": "El comando falló con código de salida {code}",
+        "execution_duration": "Duración: {duration}s",
+        "error_detail": "Detalle",
+        "error_suggestion": "💡 Sugerencia: Verifica tus credenciales de AWS y permisos IAM.",
+        "could_not_understand": "No se pudo entender: {intent}",
+        "did_you_mean": "Sé más específico. Ejemplo: 'lista los buckets de S3' o 'crea una instancia EC2 t3.micro'",
+    },
+    "pt": {
+        "plan_title": "Plano",
+        "flags_title": "🔍 Flags do comando",
+        "tip_title": "💡 Dica",
+        "related_title": "🔗 Comandos relacionados",
+        "risk_label": "Risco",
+        "cost_label": "Custo",
+        "command_label": "Comando",
+        "explanation_label": "Explicação",
+        "proceed_prompt": "Executar?",
+        "confirm_high_title": "Confirmação necessária",
+        "confirm_high_banner": "⚠️  OPERAÇÃO DE ALTO RISCO",
+        "confirm_critical_title": "⚠️  AVISO CRÍTICO",
+        "confirm_critical_banner": "🚨 OPERAÇÃO CRÍTICA — IRREVERSÍVEL",
+        "affected_resources": "Recursos afetados",
+        "estimated_cost": "Custo estimado",
+        "type_resource": 'Digite o nome do recurso ("{resource}") para confirmar',
+        "type_confirm": 'Digite "confirm" para prosseguir',
+        "type_yes_i_understand": "Para prosseguir com esta operação crítica, digite yes-i-understand:",
+        "dry_run_performing": "Executando dry-run...",
+        "dry_run_success": "Dry-run bem-sucedido — a operação teria sucesso",
+        "dry_run_failed": "Dry-Run falhou",
+        "dry_run_result": "Resultado Dry-Run",
+        "dry_run_preview": "Pré-visualização Dry-Run",
+        "cancelled": "Cancelado.",
+        "confirmation_mismatch": "A confirmação não corresponde. Cancelado.",
+        "cost_unavailable": "⚠️  Estimativa de custos indisponível — proceda com cautela",
+        "cost_preview_title": "Pré-visualização de custos",
+        "execution_success": "Executado",
+        "execution_failed": "O comando falhou com código de saída {code}",
+        "execution_duration": "Duração: {duration}s",
+        "error_detail": "Detalhe",
+        "error_suggestion": "💡 Sugestão: Verifique suas credenciais AWS e permissões IAM.",
+        "could_not_understand": "Não foi possível entender: {intent}",
+        "did_you_mean": "Seja mais específico. Exemplo: 'liste os buckets do S3' ou 'crie uma instância EC2 t3.micro'",
+    },
+    "zh": {
+        "plan_title": "计划",
+        "flags_title": "🔍 命令参数",
+        "tip_title": "💡 提示",
+        "related_title": "🔗 相关命令",
+        "risk_label": "风险",
+        "cost_label": "费用",
+        "command_label": "命令",
+        "explanation_label": "说明",
+        "proceed_prompt": "执行？",
+        "confirm_high_title": "需要确认",
+        "confirm_high_banner": "⚠️  高风险操作",
+        "confirm_critical_title": "⚠️  严重警告",
+        "confirm_critical_banner": "🚨 严重操作 — 不可逆转",
+        "affected_resources": "受影响资源",
+        "estimated_cost": "预估费用",
+        "type_resource": '输入资源名称 ("{resource}") 以确认',
+        "type_confirm": '输入 "confirm" 以继续',
+        "type_yes_i_understand": "要继续此关键操作，请输入 yes-i-understand：",
+        "dry_run_performing": "正在执行试运行...",
+        "dry_run_success": "试运行成功 — 操作可以执行",
+        "dry_run_failed": "试运行失败",
+        "dry_run_result": "试运行结果",
+        "dry_run_preview": "试运行预览",
+        "cancelled": "已取消。",
+        "confirmation_mismatch": "确认不匹配。已取消。",
+        "cost_unavailable": "⚠️  费用估算不可用 — 请谨慎操作",
+        "cost_preview_title": "费用预览",
+        "execution_success": "已执行",
+        "execution_failed": "命令失败，退出代码 {code}",
+        "execution_duration": "耗时: {duration}秒",
+        "error_detail": "详情",
+        "error_suggestion": "💡 建议：请检查您的 AWS 凭证和 IAM 权限。",
+        "could_not_understand": "无法理解: {intent}",
+        "did_you_mean": "请更具体。例如：'列出S3存储桶' 或 '创建一个EC2实例 t3.micro'",
+    },
+    "fr": {
+        "plan_title": "Plan",
+        "flags_title": "🔍 Flags de la commande",
+        "tip_title": "💡 Conseil",
+        "related_title": "🔗 Commandes associées",
+        "risk_label": "Risque",
+        "cost_label": "Coût",
+        "command_label": "Commande",
+        "explanation_label": "Explication",
+        "proceed_prompt": "Exécuter ?",
+        "confirm_high_title": "Confirmation requise",
+        "confirm_high_banner": "⚠️  OPÉRATION À HAUT RISQUE",
+        "confirm_critical_title": "⚠️  AVERTISSEMENT CRITIQUE",
+        "confirm_critical_banner": "🚨 OPÉRATION CRITIQUE — IRRÉVERSIBLE",
+        "affected_resources": "Ressources affectées",
+        "estimated_cost": "Coût estimé",
+        "type_resource": 'Tapez le nom de la ressource ("{resource}") pour confirmer',
+        "type_confirm": 'Tapez "confirm" pour continuer',
+        "type_yes_i_understand": "Pour poursuivre cette opération critique, tapez yes-i-understand :",
+        "dry_run_performing": "Exécution du dry-run...",
+        "dry_run_success": "Dry-run réussi — l'opération aurait réussi",
+        "dry_run_failed": "Dry-Run échoué",
+        "dry_run_result": "Résultat Dry-Run",
+        "dry_run_preview": "Aperçu Dry-Run",
+        "cancelled": "Annulé.",
+        "confirmation_mismatch": "La confirmation ne correspond pas. Annulé.",
+        "cost_unavailable": "⚠️  Estimation des coûts indisponible — procédez avec prudence",
+        "cost_preview_title": "Aperçu des coûts",
+        "execution_success": "Exécuté",
+        "execution_failed": "La commande a échoué avec le code {code}",
+        "execution_duration": "Durée : {duration}s",
+        "error_detail": "Détail",
+        "error_suggestion": "💡 Suggestion : Vérifiez vos identifiants AWS et permissions IAM.",
+        "could_not_understand": "Impossible de comprendre : {intent}",
+        "did_you_mean": "Soyez plus précis. Exemple : 'lister les buckets S3' ou 'créer une instance EC2 t3.micro'",
+    },
+}
+
+
+def get_labels(language: str) -> dict[str, str]:
+    """Get UI labels for the given language, falling back to English.
+
+    Args:
+        language: ISO 639-1 language code (e.g., 'es', 'en', 'pt', 'zh', 'fr').
+
+    Returns:
+        Dictionary of UI label keys to translated strings.
+    """
+    # Normalize: take first 2 chars, lowercase
+    lang = language[:2].lower() if language else "en"
+    return TRANSLATIONS.get(lang, TRANSLATIONS["en"])