ezshell 0.2.0__py3-none-any.whl

src/core/capture.py

@@ -0,0 +1,213 @@
+"""Capture de la dernière commande, de son code de sortie et de la fin de sa sortie d'erreur.
+
+Prototype M0 (DEVELOPMENT.md §7.3). Deux sources, la plus riche gagne :
+
+1. ``ezsh run -- <cmd>`` : exécute la commande, laisse stdout/stdin au terminal,
+   recopie stderr en direct et en garde la fin (~4 Ko). Écrit ``<session>.run.json``.
+2. Hooks shell (preexec/precmd, PROMPT_COMMAND) : écrivent uniquement la commande
+   et le code de sortie (``<session>.cmd`` / ``<session>.code``) : pas de sortie.
+
+Aucun contenu n'est envoyé ici : le masquage des secrets se fait avant l'envoi.
+On ne rejoue JAMAIS la commande échouée (effets de bord).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional
+
+STDERR_TAIL_BYTES = 4096
+IS_WINDOWS = os.name == "nt"
+
+
+def state_dir() -> Path:
+    """Dossier d'état par utilisateur (0700), identique à celui calculé par les hooks."""
+    override = os.environ.get("EZSH_STATE_DIR")
+    if override:
+        base = Path(override)
+    elif IS_WINDOWS:
+        # Même chemin que le hook PowerShell : %LOCALAPPDATA%\ezsh (privé à l'utilisateur).
+        local = os.environ.get("LOCALAPPDATA") or str(Path.home() / "AppData" / "Local")
+        base = Path(local) / "ezsh"
+    else:
+        runtime = os.environ.get("XDG_RUNTIME_DIR")
+        base = (
+            Path(runtime) / "ezsh"
+            if runtime
+            else Path(tempfile.gettempdir()) / f"ezsh-{os.getuid()}"
+        )
+    base.mkdir(mode=0o700, parents=True, exist_ok=True)
+    return base
+
+
+def session_key() -> str:
+    """Un état par terminal : EZSH_SESSION est exporté par les hooks (PID du shell)."""
+    return os.environ.get("EZSH_SESSION") or str(os.getppid())
+
+
+@dataclass
+class LastRun:
+    command: str
+    exit_code: Optional[int]
+    stderr_tail: str = ""
+    cwd: str = ""
+    captured_output: bool = False  # True si la sortie d'erreur a été capturée
+
+
+def _atomic_write(path: Path, text: str) -> None:
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as fh:
+        fh.write(text)
+    os.replace(tmp, path)
+
+
+def run_and_capture(argv: List[str]) -> int:
+    """Exécute ``argv`` en gardant la fin de stderr. Retourne le code de sortie de la commande."""
+    if not argv:
+        print("ezsh run: aucune commande fournie (usage : ezsh run -- <commande>)", file=sys.stderr)
+        return 2
+    tail = bytearray()
+    lock = threading.Lock()
+    launch = argv
+    if IS_WINDOWS and not shutil.which(argv[0]):
+        # Cmdlet ou alias PowerShell (Get-ChildItem, dir…) : on le lance via PowerShell.
+        exe = shutil.which("pwsh") or shutil.which("powershell")
+        if exe:
+            launch = [exe, "-NoLogo", "-NoProfile", "-Command", _powershell_script(argv)]
+    try:
+        proc = subprocess.Popen(launch, stderr=subprocess.PIPE)
+    except FileNotFoundError:
+        msg = f"ezsh: commande introuvable : {argv[0]}\n"
+        sys.stderr.write(msg)
+        _store(argv, 127, msg.encode())
+        return 127
+    except PermissionError:
+        msg = f"ezsh: permission refusée : {argv[0]}\n"
+        sys.stderr.write(msg)
+        _store(argv, 126, msg.encode())
+        return 126
+
+    def pump() -> None:
+        assert proc.stderr is not None
+        for chunk in iter(lambda: proc.stderr.read1(4096), b""):  # type: ignore[attr-defined]
+            try:
+                sys.stderr.buffer.write(chunk)
+                sys.stderr.buffer.flush()
+            except Exception:
+                pass
+            with lock:
+                tail.extend(chunk)
+                if len(tail) > STDERR_TAIL_BYTES:
+                    del tail[: len(tail) - STDERR_TAIL_BYTES]
+
+    t = threading.Thread(target=pump, daemon=True)
+    t.start()
+    # Ctrl+C arrive aussi à l'enfant (même terminal) : on le laisse décider de s'arrêter
+    # au lieu de le tuer, pour ne pas casser les programmes qui gèrent SIGINT (REPL, psql…).
+    while True:
+        try:
+            code = proc.wait()
+            break
+        except KeyboardInterrupt:
+            continue
+    if code < 0:  # tué par un signal (Unix) : convention shell 128 + n
+        code = 128 - code
+    t.join(timeout=2)
+    _store(argv, code, bytes(tail))
+    return code
+
+
+def _ps_quote(arg: str) -> str:
+    """Argument PowerShell : nu s'il est sûr (garde -Recurse comme paramètre), sinon '…'."""
+    if re.fullmatch(r"[\w\-.:/\\=+,@%]+", arg):
+        return arg
+    return "'" + arg.replace("'", "''") + "'"
+
+
+def _powershell_script(argv: List[str]) -> str:
+    """Script PowerShell qui lance `argv` et reproduit les codes de sortie d'un shell :
+    127 si la commande n'existe pas, le code du programme natif, sinon 1 en cas d'échec."""
+    name = argv[0].replace("'", "''")
+    return (
+        f"if (-not (Get-Command -Name '{name}' -ErrorAction SilentlyContinue)) {{ "
+        f"[Console]::Error.WriteLine('ezsh: commande introuvable : {name}'); exit 127 }}; "
+        f"& {' '.join(_ps_quote(a) for a in argv)}; "
+        "if (-not $?) { if ($LASTEXITCODE) { exit $LASTEXITCODE } else { exit 1 } }"
+    )
+
+
+def _store(argv: List[str], code: int, tail: bytes) -> None:
+    if IS_WINDOWS:
+        command = subprocess.list2cmdline(argv)
+    else:
+        import shlex
+
+        command = " ".join(shlex.quote(a) for a in argv)
+    payload = {
+        "command": command,
+        "exit_code": code,
+        "stderr_tail": tail.decode("utf-8", errors="replace"),
+        "cwd": os.getcwd(),
+        "ts": time.time(),
+    }
+    try:
+        _atomic_write(state_dir() / f"{session_key()}.run.json", json.dumps(payload))
+    except OSError:
+        pass  # la capture est un confort : ne jamais casser la commande
+
+
+def _read(path: Path) -> Optional[str]:
+    try:
+        return path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return None
+
+
+def read_last_run() -> Optional[LastRun]:
+    """Dernière commande de CE terminal. Utilise la capture ``run`` si elle est la plus récente."""
+    d, key = state_dir(), session_key()
+    cmd_p, code_p, run_p = d / f"{key}.cmd", d / f"{key}.code", d / f"{key}.run.json"
+
+    run = None
+    raw = _read(run_p)
+    if raw:
+        try:
+            run = json.loads(raw)
+        except json.JSONDecodeError:
+            run = None
+
+    # Les hooks suppriment run.json dès qu'une autre commande tourne :
+    # s'il existe, c'est le plus récent.
+    if run:
+        return LastRun(
+            run["command"],
+            run.get("exit_code"),
+            run.get("stderr_tail", ""),
+            run.get("cwd", ""),
+            True,
+        )
+
+    hook_cmd = (_read(cmd_p) or "").strip()
+    hook_code = (_read(code_p) or "").strip()
+
+    if hook_cmd:
+        try:
+            code = int(hook_code) if hook_code else None
+        except ValueError:
+            code = None
+        return LastRun(hook_cmd, code, "", "", False)
+    return None
+
+
+__all__ = ["run_and_capture", "read_last_run", "LastRun", "state_dir", "session_key"]

src/core/chat_bridge.py

@@ -0,0 +1,107 @@
+"""Pont entre les interfaces GUI / TUI / --explain et le fournisseur de `Alt+E`.
+
+Toutes les interfaces passent ainsi par le même chemin : proxy ezShell (ou Groq direct avec
+EZSH_DIRECT=1, ou mode simulé), validation JSON, nettoyage, plancher de risque. Le résultat
+est converti en `ChatMessageResult` pour que les interfaces existantes n'aient qu'à l'afficher.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from src.core.assistant import ChatMessageResult
+from src.core.provider import (
+    LLMProvider,
+    MissingKey,
+    ProviderError,
+    ProviderOffline,
+    QuotaExceeded,
+    UpdateRequired,
+    get_provider,
+)
+from src.core.redact import redact_secrets
+from src.core.safety import RiskLevel, SafetyReport
+from src.core.schema import InvalidResponse
+from src.core.suggest import build_request, detect_lang, get_suggestion
+from src.ui.panel import tr
+
+_RISK = {"low": RiskLevel.SAFE, "medium": RiskLevel.WARNING, "high": RiskLevel.DANGEROUS}
+
+
+def ask(
+    query: str = "",
+    *,
+    mode: str = "translate",
+    command: str = "",
+    provider: Optional[LLMProvider] = None,
+) -> ChatMessageResult:
+    """`mode` : translate (question libre), explain_error (dernier échec), explain_command."""
+    if mode == "explain_error":
+        req = build_request("")
+        if command and not req.last_command:
+            req.last_command = command
+        if query:  # texte d'erreur fourni à la main (--explain)
+            req.stderr_tail = redact_secrets(query)[-4096:]
+            req.exit_code = req.exit_code if req.exit_code is not None else 1
+    elif mode == "explain_command":
+        req = build_request(command or query)
+        req.mode = "explain_command"
+    else:
+        req = build_request(query)
+
+    s = get_suggestion(req, provider or get_provider())
+    parts = [s.response.explanation]
+    if s.response.cause:
+        parts.append(f"{tr(req.lang)['cause']} : {s.response.cause}")
+    commands = [s.command] if s.command else []
+    reports = [
+        SafetyReport(
+            command=s.command,
+            risk_level=_RISK.get(s.risk, RiskLevel.WARNING),
+            reason=s.risk_reason,
+            requires_explicit_confirmation=s.risk == "high",
+        )
+    ] if s.command else []
+    return ChatMessageResult(
+        content="\n\n".join(p for p in parts if p),
+        suggested_commands=commands,
+        safety_reports=reports,
+    )
+
+
+def provider_label(provider: LLMProvider, config=None) -> str:
+    """Libellé court du fournisseur actif, pour les barres d'état."""
+    from urllib.parse import urlparse
+
+    from src.core.provider import MockProvider
+    from src.core.proxy_client import ProxyProvider
+
+    if isinstance(provider, MockProvider):
+        return "Mock · offline"
+    if isinstance(provider, ProxyProvider):
+        return f"ezShell · {urlparse(provider.base_url).hostname or 'proxy'}"
+    model = getattr(provider, "model", "") or (config.get_effective_model() if config else "")
+    return f"Groq · {model}".rstrip(" ·")
+
+
+def describe_error(exc: Exception) -> str:
+    """Message court et traduit pour une erreur du fournisseur (mêmes textes que `Alt+E`)."""
+    t = tr(detect_lang())
+    if isinstance(exc, ProviderOffline):
+        return t["offline"]
+    if isinstance(exc, UpdateRequired):
+        return t["update_required"]
+    if isinstance(exc, QuotaExceeded):
+        if exc.scope == "anonymous":
+            return t["trial"]
+        return t["quota"].format(scope=exc.scope, reset=exc.reset_at or "?")
+    if isinstance(exc, MissingKey):
+        return t["nokey"]
+    if isinstance(exc, InvalidResponse):
+        return t["invalid"]
+    if isinstance(exc, ProviderError):
+        return t["error"]
+    return f"{t['error']} ({type(exc).__name__})"
+
+
+__all__ = ["ask", "describe_error"]

src/core/config.py

@@ -0,0 +1,238 @@
+"""
+ezShell Configuration Management
+==================================
+This module defines the ``EzShellConfig`` dataclass, which centralises every
+user-configurable setting for the ezShell application.  Configuration is
+resolved through a layered precedence chain so that more specific sources
+always win over more general ones:
+
+1. Local ``.env.local`` / ``.env`` file in the current working directory
+2. Process-level environment variables (``GROQ_API_KEY``, ``EZSHELL_MODEL``)
+3. Persisted user config file (``~/.ezshell/config.json`` or a custom path)
+4. Hard-coded default values defined in this module
+
+The :func:`EzShellConfig.load` classmethod merges all sources automatically,
+while :func:`EzShellConfig.save` serialises the current settings back to
+disk as JSON.
+
+---
+
+Gestion de la configuration d'ezShell
+=======================================
+Ce module définit le dataclass ``EzShellConfig``, qui centralise tous les
+paramètres configurables par l'utilisateur pour l'application ezShell.
+La configuration est résolue selon une chaîne de priorité : les sources
+plus spécifiques remplacent toujours les sources plus générales.
+
+1. Fichier ``.env.local`` / ``.env`` dans le répertoire de travail courant
+2. Variables d'environnement du processus (``GROQ_API_KEY``, ``EZSHELL_MODEL``)
+3. Fichier de configuration utilisateur persisté (``~/.ezshell/config.json``)
+4. Valeurs par défaut définies dans ce module
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Optional
+
+from dotenv import load_dotenv
+
+# ---------------------------------------------------------------------------
+# Module-level constants
+# ---------------------------------------------------------------------------
+
+#: Default directory where ezShell stores its persistent configuration.
+DEFAULT_CONFIG_DIR = Path.home() / ".ezshell"
+
+#: Full path to the default JSON configuration file.
+DEFAULT_CONFIG_PATH = DEFAULT_CONFIG_DIR / "config.json"
+
+#: Groq model identifier used when no model is specified by the user.
+DEFAULT_MODEL = "openai/gpt-oss-120b"
+
+#: Supported provider identifiers.
+SUPPORTED_PROVIDERS: list[str] = ["groq", "openai", "anthropic", "ollama"]
+
+#: Default model per provider.
+PROVIDER_DEFAULT_MODELS: dict[str, str] = {
+    "groq": DEFAULT_MODEL,
+    "openai": "gpt-4o-mini",
+    "anthropic": "claude-3-5-haiku-20241022",
+    "ollama": "llama3",
+}
+
+
+@dataclass
+class EzShellConfig:
+    """Centralised, immutable-style configuration for an ezShell session.
+
+    All fields have sensible defaults so that ``EzShellConfig()`` is always
+    a valid, usable configuration without any environment setup.
+
+    Attributes:
+        groq_api_key (Optional[str]): Groq platform API key used to
+            authenticate requests.  When ``None``, the value is looked up
+            from the ``GROQ_API_KEY`` environment variable at runtime via
+            :meth:`get_effective_api_key`.
+        model (str): Groq model identifier (e.g. ``"openai/gpt-oss-120b"``).
+            Overridable via the ``EZSHELL_MODEL`` environment variable.
+        temperature (float): Sampling temperature passed to the language
+            model.  Lower values (closer to 0) produce more deterministic
+            output; higher values increase creativity.  Default is ``0.2``.
+        max_tokens (int): Maximum number of tokens the model may generate in
+            a single response.  Default is ``1024``.
+        auto_suggest_fix (bool): When ``True``, ezShell automatically
+            proposes a corrected command after a shell error without waiting
+            for an explicit user request.  Default is ``True``.
+        stream_explanation (bool): When ``True``, model explanations are
+            printed incrementally as tokens arrive rather than buffered and
+            displayed all at once.  Default is ``True``.
+        max_history_items (int): Maximum number of shell-command history
+            entries retained in the session context sent to the model.
+            Default is ``100``.
+    """
+
+    groq_api_key: Optional[str] = None
+    model: str = DEFAULT_MODEL
+    temperature: float = 0.2
+    max_tokens: int = 1024
+    auto_suggest_fix: bool = True
+    stream_explanation: bool = True
+    max_history_items: int = 100
+    # --- multi-provider ---
+    provider: str = "groq"
+    openai_api_key: Optional[str] = None
+    anthropic_api_key: Optional[str] = None
+    ollama_base_url: str = "http://localhost:11434"
+
+    @classmethod
+    def load(cls, cwd: Optional[Path] = None, config_path: Optional[Path] = None) -> EzShellConfig:
+        """Build an ``EzShellConfig`` instance by merging all configuration sources.
+
+        Sources are applied from lowest to highest precedence so that each
+        subsequent source can selectively override earlier values:
+
+        1. User config JSON file (``~/.ezshell/config.json`` or *config_path*)
+        2. Process environment variables (``GROQ_API_KEY``, ``EZSHELL_MODEL``)
+        3. ``.env.local`` / ``.env`` dotenv file in *cwd* (loaded into the
+           environment before step 2 is evaluated, but ``override=False``
+           prevents it from overwriting already-set variables)
+        4. Dataclass field defaults for any key not supplied by the above
+
+        Args:
+            cwd (Optional[Path]): Directory to search for ``.env.local`` /
+                ``.env`` files.  Defaults to ``Path.cwd()`` when ``None``.
+            config_path (Optional[Path]): Explicit path to a JSON config file.
+                When ``None``, :data:`DEFAULT_CONFIG_PATH` is used.
+
+        Returns:
+            EzShellConfig: A fully initialised configuration object whose
+            field values reflect the merged result of all available sources.
+        """
+        # 1. Load local .env files if present
+        current_dir = cwd or Path.cwd()
+        env_local = current_dir / ".env.local"
+        env_default = current_dir / ".env"
+        # Prefer .env.local over .env; override=False keeps already-set vars intact
+        if env_local.is_file():
+            load_dotenv(dotenv_path=env_local, override=False)
+        elif env_default.is_file():
+            load_dotenv(dotenv_path=env_default, override=False)
+
+        # 2. Base dict from user config JSON file if it exists
+        data: dict = {}
+        target_config = config_path or DEFAULT_CONFIG_PATH
+        if target_config.is_file():
+            try:
+                with open(target_config, "r", encoding="utf-8") as f:
+                    file_data = json.load(f)
+                    if isinstance(file_data, dict):
+                        data.update(file_data)
+            except Exception:
+                # Silently ignore malformed or unreadable config files so that
+                # a corrupted file never prevents ezShell from starting.
+                pass
+
+        # 3. Environment variables take precedence over config file
+        env_map = {
+            "GROQ_API_KEY": "groq_api_key",
+            "OPENAI_API_KEY": "openai_api_key",
+            "ANTHROPIC_API_KEY": "anthropic_api_key",
+            "EZSHELL_MODEL": "model",
+            "EZSHELL_PROVIDER": "provider",
+            "OLLAMA_BASE_URL": "ollama_base_url",
+        }
+        for env_var, field_name in env_map.items():
+            val = os.environ.get(env_var)
+            if val:
+                data[field_name] = val
+
+        valid_keys = {
+            "groq_api_key", "model", "temperature", "max_tokens",
+            "auto_suggest_fix", "stream_explanation", "max_history_items",
+            "provider", "openai_api_key", "anthropic_api_key", "ollama_base_url",
+        }
+        filtered_data = {k: v for k, v in data.items() if k in valid_keys}
+
+        return cls(**filtered_data)
+
+    def save(self, path: Optional[Path] = None) -> None:
+        """Persist the current configuration to a JSON file on disk.
+
+        Args:
+            path (Optional[Path]): Destination. Defaults to ``~/.ezshell/config.json``.
+
+        Raises:
+            OSError: If the file cannot be created or written.
+        """
+        target_path = path or DEFAULT_CONFIG_PATH
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(target_path, "w", encoding="utf-8") as f:
+            json.dump(asdict(self), f, indent=2)
+
+    def get_effective_api_key(self) -> Optional[str]:
+        """Return the API key for the currently active provider.
+
+        Ollama is local — it requires no key and returns ``None``.
+
+        Returns:
+            Optional[str]: Active API key, or ``None``.
+        """
+        if self.provider == "openai":
+            return self.openai_api_key or os.environ.get("OPENAI_API_KEY")
+        if self.provider == "anthropic":
+            return self.anthropic_api_key or os.environ.get("ANTHROPIC_API_KEY")
+        if self.provider == "ollama":
+            return None
+        # Default: groq
+        return self.groq_api_key or os.environ.get("GROQ_API_KEY")
+
+    def get_effective_model(self) -> str:
+        """Return the model name to use for the active provider.
+
+        If :attr:`model` is still the Groq default and the provider has
+        changed, returns the canonical default for that provider.
+
+        Returns:
+            str: Model identifier for the active provider.
+        """
+        if self.model == DEFAULT_MODEL and self.provider in PROVIDER_DEFAULT_MODELS:
+            return PROVIDER_DEFAULT_MODELS[self.provider]
+        return self.model
+
+
+# ---------------------------------------------------------------------------
+# Public API surface
+# ---------------------------------------------------------------------------
+
+__all__ = [
+    "DEFAULT_CONFIG_DIR",
+    "DEFAULT_CONFIG_PATH",
+    "DEFAULT_MODEL",
+    "SUPPORTED_PROVIDERS",
+    "PROVIDER_DEFAULT_MODELS",
+    "EzShellConfig",
+]