clified 0.4.0__py3-none-any.whl

clified/__init__.py

@@ -0,0 +1,3 @@
+"""Clified — instalador universal e biblioteca CLI."""
+
+__version__ = "0.4.0"

clified/__main__.py

@@ -0,0 +1,7 @@
+"""Permite ``python -m clified``."""
+
+import sys
+
+from clified.installer.unified import main
+
+sys.exit(main())

clified/bundled/config/clified.yml.example

@@ -0,0 +1,17 @@
+# Configuração global opcional do Clified.
+# Copie para config/clified.yml para personalizar.
+
+base_dir: ~/.clified
+
+logging:
+  level: INFO
+
+retry:
+  max_attempts: 3
+  base_delay: 2.0
+  max_delay: 60.0
+
+install:
+  prefix: ~/.local
+  use_uv: true
+  default_python: python3

clified/bundled/config/gamedev-constraints.txt.example

@@ -0,0 +1,5 @@
+# Constraints para ``clified-install all`` em workspaces ML (GameDev)
+# Copie para config/install-all-constraints.txt quando usar várias tools PyTorch
+
+transformers==4.51.3
+numpy>=2.4.5,<3

clified/bundled/config/install-all-constraints.txt

@@ -0,0 +1,2 @@
+# Constraints opcionais para ``clified-install all`` (pip -c).
+# Deixe vazio ou comente linhas que não usar.

clified/bundled/examples/tools.denv.yaml.example

@@ -0,0 +1,17 @@
+# Exemplo: registrar denv (LocatelliDockerManager) via Clified
+
+workspace:
+  root: "/home/maikeu/GitClones"
+  name: "GitClones"
+
+tools:
+  denv:
+    name: "DENV"
+    kind: python
+    folder: LocatelliDockerManager
+    cli_name: denv
+    python_module: denv
+    description: "Docker Environment Manager — Swarm, stacks, diagnóstico"
+    min_python: [3, 12]
+    post_install: clified.hooks:register_mcp_serve
+    # Instalação: poetry/pip install -e no projecto; Clified gere venv + wrapper

clified/bundled/examples/tools.gamedev.yaml.example

@@ -0,0 +1,63 @@
+# Exemplo: migrar monorepo GameDev para Clified
+# Copie secções relevantes para o seu tools.yaml
+# Hooks específicos ficam no repo GameDev (gamedev_shared.installer.clified_hooks)
+
+workspace:
+  root: "/caminho/para/GameDev"
+  name: "GameDev"
+  shared_python:
+    path: Shared
+    import_name: gamedev_shared
+    src_subpath: src
+
+tools:
+  text2d:
+    kind: python
+    folder: Text2D
+    cli_name: text2d
+    python_module: text2d
+    description: "CLI text-to-image"
+    min_python: [3, 13]
+    needs_pytorch: true
+    install_order: -2
+    post_install: clified.hooks:pip_check
+
+  text3d:
+    kind: python
+    folder: Text3D
+    cli_name: text3d
+    python_module: text3d
+    description: "Pipeline text-to-3D"
+    min_python: [3, 13]
+    needs_pytorch: true
+    install_order: -1
+    install_before: [text2d]
+    cross_deps: [text2d]
+    post_install: gamedev_shared.installer.clified_hooks:text3d_post_install
+
+  materialize:
+    kind: rust
+    folder: Materialize
+    cli_name: materialize
+    cargo_bin_name: materialize-cli
+    description: "PBR maps via GPU"
+
+  text2sound:
+    kind: python
+    folder: Text2Sound
+    cli_name: text2sound
+    python_module: text2sound
+    description: "CLI text-to-audio"
+    min_python: [3, 13]
+    needs_pytorch: true
+    custom_install: gamedev_shared.installer.clified_hooks:text2sound_custom_install
+
+  paint3d:
+    kind: python
+    folder: Paint3D
+    cli_name: paint3d
+    python_module: paint3d
+    description: "Texturização 3D PBR"
+    min_python: [3, 13]
+    needs_pytorch: true
+    post_install: gamedev_shared.installer.clified_hooks:paint3d_post_install

clified/bundled/examples/tools.pc.yaml.example

@@ -0,0 +1,17 @@
+# Exemplo: registrar pc CLI (ProjetoCursor) via Clified
+
+workspace:
+  root: "/home/maikeu/GitClones/ProjetoCursor"
+  name: "ProjetoCursor"
+
+tools:
+  pc:
+    name: "PC CLI"
+    kind: python
+    folder: tools
+    cli_name: pc
+    python_module: pc
+    description: "Flutter + Supabase + deploy — Projeto Cursor"
+    min_python: [3, 10]
+    custom_install: clified_install:custom_install
+    post_install: clified_install:post_install

clified/bundled/tools.yaml.example

@@ -0,0 +1,8 @@
+# Template — copiado para ~/.config/clified/tools.yaml na primeira execução
+# Cada projecto deve usar o seu tools.yaml via CLIFIED_TOOLS (recomendado).
+
+workspace:
+  root: .
+  name: "Workspace"
+
+tools: {}

clified/cli/__init__.py

@@ -0,0 +1,19 @@
+"""Utilitários CLI reutilizáveis."""
+
+from .decorators import (
+    EXIT_CONFIG_ERROR,
+    EXIT_GENERAL_ERROR,
+    EXIT_INFRA_ERROR,
+    EXIT_SUCCESS,
+    handle_cli_errors,
+)
+from .output import OutputFormatter
+
+__all__ = [
+    "EXIT_CONFIG_ERROR",
+    "EXIT_GENERAL_ERROR",
+    "EXIT_INFRA_ERROR",
+    "EXIT_SUCCESS",
+    "OutputFormatter",
+    "handle_cli_errors",
+]

clified/cli/app.py

@@ -0,0 +1,56 @@
+"""Scaffold Click reutilizável (--json, --quiet, --verbose)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+try:
+    import click
+except ImportError:  # pragma: no cover - optional dep
+    click = None  # type: ignore[assignment]
+
+from .output import OutputFormatter, get_output_formatter
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def require_click() -> None:
+    if click is None:
+        msg = "Click não instalado. Use: pip install clified[cli]"
+        raise ImportError(
+            msg,
+        )
+
+
+def create_cli_group(name: str = "cli", help_text: str = "CLI tool") -> Any:
+    """Cria grupo Click com opções globais de output."""
+    require_click()
+
+    @click.group(name=name, help=help_text)
+    @click.option(
+        "--json", "json_output", is_flag=True, help="Saída JSON (machine-readable)"
+    )
+    @click.option("-q", "--quiet", is_flag=True, help="Suprime output decorativo")
+    @click.option("-v", "--verbose", is_flag=True, help="Modo verboso")
+    @click.pass_context
+    def group(
+        ctx: click.Context, json_output: bool, quiet: bool, verbose: bool
+    ) -> None:
+        ctx.ensure_object(dict)
+        ctx.obj["output"] = OutputFormatter(json_mode=json_output, quiet=quiet)
+        ctx.obj["verbose"] = verbose
+
+    return group
+
+
+def pass_output(func: Callable) -> Callable:
+    """Decorator que injecta ``OutputFormatter`` como kwarg ``output``."""
+    require_click()
+
+    @click.pass_context
+    def wrapper(ctx: click.Context, *args: Any, **kwargs: Any) -> Any:
+        kwargs["output"] = get_output_formatter(ctx)
+        return func(*args, **kwargs)
+
+    return wrapper

clified/cli/decorators.py

@@ -0,0 +1,61 @@
+"""Decorators para comandos CLI."""
+
+from __future__ import annotations
+
+import functools
+import sys
+from typing import TYPE_CHECKING
+
+from clified.core.exceptions import (
+    ClifiedError,
+    ConfigError,
+    DeploymentError,
+    InfrastructureError,
+    InstallError,
+    NetworkError,
+    ValidationError,
+)
+from clified.logging import Logger
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+logger = Logger()
+
+EXIT_SUCCESS = 0
+EXIT_GENERAL_ERROR = 1
+EXIT_CONFIG_ERROR = 2
+EXIT_INFRA_ERROR = 3
+
+_CONFIG_EXCEPTIONS: tuple[type[Exception], ...] = (ConfigError, ValidationError)
+_INFRA_EXCEPTIONS: tuple[type[Exception], ...] = (
+    InfrastructureError,
+    NetworkError,
+    DeploymentError,
+    InstallError,
+)
+
+
+def handle_cli_errors(func: Callable) -> Callable:
+    """Padroniza exit codes: 0 ok, 1 geral, 2 config, 3 infra."""
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except (SystemExit, KeyboardInterrupt):
+            raise
+        except _CONFIG_EXCEPTIONS as exc:
+            logger.error(str(exc))
+            sys.exit(EXIT_CONFIG_ERROR)
+        except _INFRA_EXCEPTIONS as exc:
+            logger.error(str(exc))
+            sys.exit(EXIT_INFRA_ERROR)
+        except ClifiedError as exc:
+            logger.error(str(exc))
+            sys.exit(EXIT_GENERAL_ERROR)
+        except Exception as exc:
+            logger.error(f"Erro inesperado: {exc}")
+            sys.exit(EXIT_GENERAL_ERROR)
+
+    return wrapper

clified/cli/output.py

@@ -0,0 +1,103 @@
+"""Saída CLI: Rich, JSON e quiet."""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+
+class OutputFormatter:
+    """Formata saída para humanos ou máquinas (JSON/quiet)."""
+
+    def __init__(self, json_mode: bool = False, quiet: bool = False) -> None:
+        self.json_mode = json_mode
+        self.quiet = quiet
+        self._console = Console(stderr=True) if json_mode else Console()
+
+    @property
+    def is_json(self) -> bool:
+        return self.json_mode
+
+    @property
+    def is_quiet(self) -> bool:
+        return self.quiet
+
+    @property
+    def console(self) -> Console:
+        return self._console
+
+    def success(self, data: dict[str, Any], message: str = "") -> None:
+        if self.json_mode:
+            self._print_json({"status": "success", **data})
+        elif not self.quiet and message:
+            self._console.print(f"[green]{message}[/green]")
+
+    def error(self, message: str, details: dict[str, Any] | None = None) -> None:
+        if self.json_mode:
+            payload: dict[str, Any] = {"status": "error", "error": message}
+            if details:
+                payload["details"] = details
+            self._print_json(payload)
+        else:
+            self._console.print(f"[red]{message}[/red]", highlight=False)
+
+    def info(self, message: str) -> None:
+        if self.json_mode or self.quiet:
+            return
+        self._console.print(message)
+
+    def warning(self, message: str) -> None:
+        if self.json_mode or self.quiet:
+            return
+        self._console.print(f"[yellow]{message}[/yellow]")
+
+    def warn(self, message: str) -> None:
+        """Alias de ``warning``."""
+        self.warning(message)
+
+    def data(self, payload: dict[str, Any], title: str = "") -> None:
+        if self.json_mode:
+            self._print_json({"status": "success", **payload})
+        elif not self.quiet:
+            if title:
+                text = json.dumps(payload, indent=2, default=str, ensure_ascii=False)
+                self._console.print(Panel(text, title=title, border_style="blue"))
+            else:
+                self._console.print_json(data=payload)
+
+    def table(
+        self,
+        rows: list[dict[str, Any]],
+        columns: list[str],
+        title: str = "",
+        json_key: str = "items",
+    ) -> None:
+        if self.json_mode:
+            self._print_json({"status": "success", json_key: rows, "count": len(rows)})
+            return
+        if self.quiet:
+            return
+        t = Table(title=title, box=box.ROUNDED, show_header=True, header_style="bold")
+        for col in columns:
+            t.add_column(col)
+        for row in rows:
+            t.add_row(*[str(row.get(col, "")) for col in columns])
+        self._console.print(t)
+
+    def _print_json(self, obj: Any) -> None:
+        sys.stdout.write(json.dumps(obj, indent=2, default=str, ensure_ascii=False))
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+
+
+def get_output_formatter(ctx: Any = None) -> OutputFormatter:
+    """Obtém formatter do contexto Click ou cria um por defeito."""
+    if ctx is not None and hasattr(ctx, "obj") and ctx.obj and "output" in ctx.obj:
+        return ctx.obj["output"]
+    return OutputFormatter()

clified/cli/progress.py

@@ -0,0 +1,106 @@
+"""UI de etapas para operações longas (inspirado no DeployUI do pc CLI)."""
+
+from __future__ import annotations
+
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from clified.logging import Logger
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator
+
+
+@dataclass
+class Step:
+    name: str
+    description: str = ""
+
+
+@dataclass
+class StepResult:
+    name: str
+    success: bool
+    duration: float
+    message: str = ""
+
+
+class StepRunner:
+    """Executa etapas nomeadas com logging Rich/ANSI."""
+
+    def __init__(
+        self,
+        steps: list[Step],
+        *,
+        title: str = "Instalação",
+        logger: Logger | None = None,
+        quiet: bool = False,
+    ) -> None:
+        self.steps = steps
+        self.title = title
+        self.logger = logger or Logger()
+        self.quiet = quiet
+        self.results: list[StepResult] = []
+        self._start = time.time()
+
+    @contextmanager
+    def step(self, index: int) -> Iterator[None]:
+        if index < 0 or index >= len(self.steps):
+            msg = f"Step index {index} fora do intervalo"
+            raise IndexError(msg)
+        spec = self.steps[index]
+        if not self.quiet:
+            self.logger.step(f"[{index + 1}/{len(self.steps)}] {spec.name}")
+            if spec.description:
+                self.logger.info(spec.description)
+        t0 = time.time()
+        success = True
+        message = ""
+        try:
+            yield
+        except Exception as exc:
+            success = False
+            message = str(exc)
+            raise
+        finally:
+            duration = time.time() - t0
+            self.results.append(
+                StepResult(
+                    name=spec.name, success=success, duration=duration, message=message
+                ),
+            )
+            if success and not self.quiet:
+                self.logger.success(f"{spec.name} ({duration:.1f}s)")
+
+    def run(self, actions: list[Callable[[], Any]]) -> bool:
+        if len(actions) != len(self.steps):
+            msg = "Número de acções deve igualar número de etapas"
+            raise ValueError(msg)
+        if not self.quiet:
+            self.logger.header(self.title)
+        ok = True
+        for i, action in enumerate(actions):
+            try:
+                with self.step(i):
+                    action()
+            except Exception:
+                ok = False
+                break
+        return ok
+
+    def summary(self) -> dict[str, Any]:
+        return {
+            "title": self.title,
+            "total_seconds": time.time() - self._start,
+            "steps": [
+                {
+                    "name": r.name,
+                    "success": r.success,
+                    "duration": round(r.duration, 2),
+                    "message": r.message,
+                }
+                for r in self.results
+            ],
+        }

clified/core/__init__.py

@@ -0,0 +1,56 @@
+"""Core Clified — config, retry, circuit breaker, state."""
+
+from .circuit_breaker import CircuitBreaker, CircuitBreakerConfig, get_circuit_breaker
+from .config import (
+    ClifiedConfig,
+    ConfigManager,
+    InstallConfig,
+    LoggingConfig,
+    RetryConfig,
+)
+from .exceptions import (
+    ClifiedError,
+    ConfigError,
+    ConnectionError,
+    DeploymentError,
+    InfrastructureError,
+    InstallError,
+    NetworkError,
+    RetryableError,
+    TimeoutError,
+    ToolError,
+    ValidationError,
+)
+from .paths import find_project_root, resolve_project_file
+from .retry import RetryEngine, RetryPolicy, RetryResult, with_retry
+from .state_store import StateStore, get_state_store
+
+__all__ = [
+    "CircuitBreaker",
+    "CircuitBreakerConfig",
+    "ClifiedConfig",
+    "ClifiedError",
+    "ConfigError",
+    "ConfigManager",
+    "ConnectionError",
+    "DeploymentError",
+    "InfrastructureError",
+    "InstallConfig",
+    "InstallError",
+    "LoggingConfig",
+    "NetworkError",
+    "RetryConfig",
+    "RetryEngine",
+    "RetryPolicy",
+    "RetryResult",
+    "RetryableError",
+    "StateStore",
+    "TimeoutError",
+    "ToolError",
+    "ValidationError",
+    "find_project_root",
+    "get_circuit_breaker",
+    "get_state_store",
+    "resolve_project_file",
+    "with_retry",
+]