aparta 0.1.0__py3-none-any.whl

aparta/__init__.py

@@ -0,0 +1,3 @@
+"""aparta — isolamento de contas de desenvolvimento por pasta de projeto."""
+
+__version__ = "0.1.0"

aparta/agents/__init__.py

@@ -0,0 +1,23 @@
+"""Adapters de agentes de IA de terminal.
+
+Todos os módulos deste pacote são importados automaticamente; qualquer
+subclasse de AgentAdapter com `name` definido entra no REGISTRY sozinha.
+Adicionar um agente novo = criar um arquivo aqui.
+"""
+
+from __future__ import annotations
+
+import importlib
+import pkgutil
+
+from .base import REGISTRY, AgentAdapter
+
+for _mod in pkgutil.iter_modules(__path__):
+    if _mod.name != "base":
+        importlib.import_module(f"{__name__}.{_mod.name}")
+
+ADAPTERS: dict[str, type[AgentAdapter]] = REGISTRY
+
+
+def get_adapters(names: list[str]) -> list[AgentAdapter]:
+    return [ADAPTERS[n]() for n in names if n in ADAPTERS]

aparta/agents/antigravity.py

@@ -0,0 +1,68 @@
+"""Adapter Antigravity (IDE agent-first do Google).
+
+O Antigravity é um fork do VS Code e lê as configurações de workspace em
+.vscode/settings.json; o terminal integrado (usado também pelos agentes ao
+executar comandos) honra "terminal.integrated.env.<plataforma>". Injetamos as
+variáveis em terminal.integrated.env.osx e .linux, preservando o resto.
+
+Limitação conhecida: não há (até o momento) um mecanismo documentado do
+Antigravity para injetar env diretamente no processo do agente fora do
+terminal integrado. Se os comandos do agente não herdarem essas variáveis na
+sua versão, combine este adapter com o adapter `direnv` (.envrc) como
+fallback — o direnv aplica o env a qualquer shell que entre na pasta.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from ..fsutil import SafeWriter
+from .base import AgentAdapter
+
+_PLATFORM_KEYS = ("terminal.integrated.env.osx", "terminal.integrated.env.linux")
+
+
+def merge_vscode_settings(existing_text: str, env: dict[str, str]) -> str:
+    """Faz merge do env em terminal.integrated.env.{osx,linux} preservando o resto."""
+    data = json.loads(existing_text) if existing_text.strip() else {}
+    if not isinstance(data, dict):
+        raise ValueError(".vscode/settings.json não contém um objeto JSON")
+    for key in _PLATFORM_KEYS:
+        current = data.get(key, {})
+        if not isinstance(current, dict):
+            current = {}
+        data[key] = {**current, **env}
+    return json.dumps(data, indent=2, ensure_ascii=False) + "\n"
+
+
+class AntigravityAdapter(AgentAdapter):
+    name = "antigravity"
+    display_name = "Antigravity"
+
+    def settings_path(self, repo: Path) -> Path:
+        return repo / ".vscode" / "settings.json"
+
+    def detect(self, repo: Path) -> bool:
+        # Workspace settings valem para qualquer repo aberto no Antigravity.
+        return True
+
+    def inject(self, repo: Path, env: dict[str, str], writer: SafeWriter) -> bool:
+        path = self.settings_path(repo)
+        existing = path.read_text() if path.exists() else ""
+        return writer.write_text(path, merge_vscode_settings(existing, env))
+
+    def validate(self, repo: Path, env: dict[str, str]) -> tuple[bool, str]:
+        path = self.settings_path(repo)
+        if not path.exists():
+            return False, ".vscode/settings.json ausente"
+        try:
+            data = json.loads(path.read_text())
+        except json.JSONDecodeError:
+            return False, ".vscode/settings.json inválido"
+        for key in _PLATFORM_KEYS:
+            current = data.get(key, {})
+            missing = [k for k, v in env.items() if current.get(k) != v]
+            if missing:
+                return False, f"{key} divergente: {', '.join(missing)}"
+        return True, "env ok"

aparta/agents/base.py

@@ -0,0 +1,40 @@
+"""Interface comum dos adapters de agentes: detect, inject, validate.
+
+Registry central: qualquer subclasse concreta de AgentAdapter com `name`
+definido é registrada automaticamente. Adicionar um agente novo = criar um
+arquivo neste pacote (os módulos são importados por aparta.agents).
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from ..fsutil import SafeWriter
+
+REGISTRY: dict[str, type["AgentAdapter"]] = {}
+
+
+class AgentAdapter(ABC):
+    """Um adapter sabe injetar variáveis de ambiente em um agente para um repo."""
+
+    name: str = ""
+    display_name: str = ""
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        super().__init_subclass__(**kwargs)
+        if cls.name:
+            cls.display_name = cls.display_name or cls.name
+            REGISTRY[cls.name] = cls
+
+    @abstractmethod
+    def detect(self, repo: Path) -> bool:
+        """True se o agente é usado (ou faz sentido) neste repositório."""
+
+    @abstractmethod
+    def inject(self, repo: Path, env: dict[str, str], writer: SafeWriter) -> bool:
+        """Faz merge das variáveis no arquivo de config do agente. True se mudou algo."""
+
+    @abstractmethod
+    def validate(self, repo: Path, env: dict[str, str]) -> tuple[bool, str]:
+        """(ok, mensagem) — as variáveis esperadas estão presentes?"""

aparta/agents/claude_code.py

@@ -0,0 +1,53 @@
+"""Adapter Claude Code: campo "env" em .claude/settings.local.json (merge, nunca substitui)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from ..fsutil import SafeWriter
+from .base import AgentAdapter
+
+
+def merge_settings_env(existing_text: str, env: dict[str, str]) -> str:
+    """Faz merge do objeto env preservando todo o resto do JSON."""
+    data = json.loads(existing_text) if existing_text.strip() else {}
+    if not isinstance(data, dict):
+        raise ValueError("settings.local.json não contém um objeto JSON")
+    current_env = data.get("env", {})
+    if not isinstance(current_env, dict):
+        current_env = {}
+    data["env"] = {**current_env, **env}
+    return json.dumps(data, indent=2, ensure_ascii=False) + "\n"
+
+
+class ClaudeCodeAdapter(AgentAdapter):
+    name = "claude-code"
+    display_name = "Claude Code"
+
+    def settings_path(self, repo: Path) -> Path:
+        return repo / ".claude" / "settings.local.json"
+
+    def detect(self, repo: Path) -> bool:
+        # Claude Code funciona em qualquer repo; consideramos sempre aplicável.
+        return True
+
+    def inject(self, repo: Path, env: dict[str, str], writer: SafeWriter) -> bool:
+        path = self.settings_path(repo)
+        existing = path.read_text() if path.exists() else ""
+        merged = merge_settings_env(existing, env)
+        return writer.write_text(path, merged)
+
+    def validate(self, repo: Path, env: dict[str, str]) -> tuple[bool, str]:
+        path = self.settings_path(repo)
+        if not path.exists():
+            return False, "settings.local.json ausente"
+        try:
+            data = json.loads(path.read_text())
+        except json.JSONDecodeError:
+            return False, "settings.local.json inválido"
+        current = data.get("env", {})
+        missing = [k for k, v in env.items() if current.get(k) != v]
+        if missing:
+            return False, f"env divergente: {', '.join(missing)}"
+        return True, "env ok"

aparta/agents/codex.py

@@ -0,0 +1,50 @@
+"""Adapter Codex: seção [env] em .codex/config.toml do repositório (merge)."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import tomli_w
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:  # pragma: no cover
+    import tomli as tomllib
+
+from ..fsutil import SafeWriter
+from .base import AgentAdapter
+
+
+def merge_codex_env(existing_text: str, env: dict[str, str]) -> str:
+    data = tomllib.loads(existing_text) if existing_text.strip() else {}
+    current = data.get("env", {})
+    if not isinstance(current, dict):
+        current = {}
+    data["env"] = {**current, **env}
+    return tomli_w.dumps(data)
+
+
+class CodexAdapter(AgentAdapter):
+    name = "codex"
+    display_name = "Codex CLI"
+
+    def config_path(self, repo: Path) -> Path:
+        return repo / ".codex" / "config.toml"
+
+    def detect(self, repo: Path) -> bool:
+        return (repo / ".codex").exists()
+
+    def inject(self, repo: Path, env: dict[str, str], writer: SafeWriter) -> bool:
+        path = self.config_path(repo)
+        existing = path.read_text() if path.exists() else ""
+        return writer.write_text(path, merge_codex_env(existing, env))
+
+    def validate(self, repo: Path, env: dict[str, str]) -> tuple[bool, str]:
+        path = self.config_path(repo)
+        if not path.exists():
+            return False, "config.toml ausente"
+        data = tomllib.loads(path.read_text())
+        current = data.get("env", {})
+        missing = [k for k, v in env.items() if current.get(k) != v]
+        return (not missing, "env ok" if not missing else f"env divergente: {', '.join(missing)}")

aparta/agents/direnv.py

@@ -0,0 +1,49 @@
+"""Adapter genérico direnv: linhas `export VAR=...` no .envrc (adiciona só se ausentes)."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from ..fsutil import SafeWriter
+from .base import AgentAdapter
+
+
+def merge_envrc(existing_text: str, env: dict[str, str]) -> str:
+    lines = existing_text.splitlines()
+    out = list(lines)
+    for key, value in env.items():
+        pattern = re.compile(rf"^\s*export\s+{re.escape(key)}=")
+        replaced = False
+        for i, line in enumerate(out):
+            if pattern.match(line):
+                out[i] = f'export {key}="{value}"'
+                replaced = True
+                break
+        if not replaced:
+            out.append(f'export {key}="{value}"')
+    return "\n".join(out) + "\n"
+
+
+class DirenvAdapter(AgentAdapter):
+    name = "direnv"
+    display_name = "direnv (genérico)"
+
+    def envrc_path(self, repo: Path) -> Path:
+        return repo / ".envrc"
+
+    def detect(self, repo: Path) -> bool:
+        return True
+
+    def inject(self, repo: Path, env: dict[str, str], writer: SafeWriter) -> bool:
+        path = self.envrc_path(repo)
+        existing = path.read_text() if path.exists() else ""
+        return writer.write_text(path, merge_envrc(existing, env))
+
+    def validate(self, repo: Path, env: dict[str, str]) -> tuple[bool, str]:
+        path = self.envrc_path(repo)
+        if not path.exists():
+            return False, ".envrc ausente"
+        text = path.read_text()
+        missing = [k for k, v in env.items() if f'export {k}="{v}"' not in text]
+        return (not missing, "env ok" if not missing else f"faltando: {', '.join(missing)}")

aparta/agents/gemini.py

@@ -0,0 +1,59 @@
+"""Adapter Gemini CLI: variáveis em <repo>/.gemini/.env (mecanismo nativo).
+
+O Gemini CLI carrega automaticamente variáveis de ambiente de arquivos .env,
+procurando primeiro <projeto>/.gemini/.env, depois <projeto>/.env, subindo
+até a raiz do projeto (.git) ou a home. Usamos .gemini/.env porque é o local
+específico do Gemini (não interfere no .env da aplicação) e porque algumas
+variáveis só são lidas de lá.
+Ref.: google-gemini/gemini-cli docs/reference/configuration.md
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from ..fsutil import SafeWriter
+from .base import AgentAdapter
+
+
+def merge_dotenv(existing_text: str, env: dict[str, str]) -> str:
+    """Atualiza/adiciona linhas KEY="value" preservando o resto do arquivo."""
+    lines = existing_text.splitlines()
+    out = list(lines)
+    for key, value in env.items():
+        pattern = re.compile(rf"^\s*(export\s+)?{re.escape(key)}=")
+        replaced = False
+        for i, line in enumerate(out):
+            if pattern.match(line):
+                out[i] = f'{key}="{value}"'
+                replaced = True
+                break
+        if not replaced:
+            out.append(f'{key}="{value}"')
+    return "\n".join(out) + "\n"
+
+
+class GeminiAdapter(AgentAdapter):
+    name = "gemini"
+    display_name = "Gemini CLI"
+
+    def env_path(self, repo: Path) -> Path:
+        return repo / ".gemini" / ".env"
+
+    def detect(self, repo: Path) -> bool:
+        # O Gemini CLI cria .gemini/ sob demanda; o adapter é sempre aplicável.
+        return True
+
+    def inject(self, repo: Path, env: dict[str, str], writer: SafeWriter) -> bool:
+        path = self.env_path(repo)
+        existing = path.read_text() if path.exists() else ""
+        return writer.write_text(path, merge_dotenv(existing, env))
+
+    def validate(self, repo: Path, env: dict[str, str]) -> tuple[bool, str]:
+        path = self.env_path(repo)
+        if not path.exists():
+            return False, ".gemini/.env ausente"
+        text = path.read_text()
+        missing = [k for k, v in env.items() if f'{k}="{v}"' not in text]
+        return (not missing, "env ok" if not missing else f"faltando: {', '.join(missing)}")

aparta/backends/gcloud.py

@@ -0,0 +1,50 @@
+"""Backend gcloud: configurations nomeadas selecionadas por CLOUDSDK_ACTIVE_CONFIG_NAME."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+
+from rich.console import Console
+
+from ..fsutil import SafeWriter
+from ..profiles import Profile
+
+console = Console()
+
+
+def _run(args: list[str], config_name: str | None = None) -> subprocess.CompletedProcess:
+    env = dict(os.environ)
+    if config_name:
+        env["CLOUDSDK_ACTIVE_CONFIG_NAME"] = config_name
+    return subprocess.run(args, env=env, capture_output=True, text=True)
+
+
+def apply_gcloud(profile: Profile, writer: SafeWriter) -> None:
+    if not (profile.gcloud_account or profile.gcloud_project):
+        return
+    name = profile.name
+
+    cmds: list[tuple[list[str], str | None]] = [
+        (["gcloud", "config", "configurations", "create", name, "--no-activate"], None)
+    ]
+    if profile.gcloud_account:
+        cmds.append((["gcloud", "config", "set", "account", profile.gcloud_account], name))
+    if profile.gcloud_project:
+        cmds.append((["gcloud", "config", "set", "project", profile.gcloud_project], name))
+
+    if writer.dry_run:
+        for args, cfg in cmds:
+            prefix = f"CLOUDSDK_ACTIVE_CONFIG_NAME={cfg} " if cfg else ""
+            console.print(f"[yellow]--dry-run[/yellow] {prefix}{' '.join(args)}")
+        return
+
+    create = _run(*cmds[0])
+    if create.returncode != 0 and "already exists" not in create.stderr:
+        console.print(f"[red]gcloud configurations create falhou:[/red] {create.stderr.strip()}")
+        return
+    for args, cfg in cmds[1:]:
+        r = _run(args, cfg)
+        if r.returncode != 0:
+            console.print(f"[red]{' '.join(args)} falhou:[/red] {r.stderr.strip()}")
+    console.print(f"[green]gcloud:[/green] configuração '{name}' pronta")

aparta/backends/gh.py

@@ -0,0 +1,59 @@
+"""Backend GitHub CLI: diretório de config paralelo ~/.config/gh-<contexto>.
+
+Os tokens ficam no keyring do macOS, então copiar ~/.config/gh e trocar o
+usuário ativo com GH_CONFIG_DIR apontando para a cópia funciona sem novo login.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+from rich.console import Console
+
+from ..fsutil import SafeWriter
+from ..profiles import Profile
+
+console = Console()
+
+
+def apply_gh(profile: Profile, writer: SafeWriter, home: Path | None = None) -> None:
+    if not profile.gh_user:
+        return
+    home = home or Path.home()
+    src = home / ".config" / "gh"
+    dst = home / ".config" / f"gh-{profile.name}"
+
+    if not src.exists():
+        console.print("[yellow]aviso:[/yellow] ~/.config/gh não existe — rode `gh auth login` antes.")
+        return
+
+    if writer.dry_run:
+        if not dst.exists():
+            console.print(f"[yellow]--dry-run[/yellow] copiaria {src} -> {dst}")
+        console.print(
+            f"[yellow]--dry-run[/yellow] GH_CONFIG_DIR={dst} gh auth switch --user {profile.gh_user}"
+        )
+        return
+
+    if not dst.exists():
+        shutil.copytree(src, dst)
+        console.print(f"[green]criado:[/green] {dst}")
+
+    result = subprocess.run(
+        ["gh", "auth", "switch", "--user", profile.gh_user],
+        env={"GH_CONFIG_DIR": str(dst), "PATH": _path_env()},
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        console.print(f"[red]gh auth switch falhou:[/red] {result.stderr.strip()}")
+    else:
+        console.print(f"[green]gh:[/green] usuário ativo em {dst.name}: {profile.gh_user}")
+
+
+def _path_env() -> str:
+    import os
+
+    return os.environ.get("PATH", "/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin")

aparta/backends/git.py

@@ -0,0 +1,84 @@
+"""Backend git: gitconfig por contexto + includeIf no ~/.gitconfig (merge, nunca substitui)."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from ..fsutil import SafeWriter
+from ..profiles import Profile
+
+
+def context_gitconfig_path(profile: Profile, home: Path) -> Path:
+    return home / f".gitconfig-{profile.name}"
+
+
+def render_context_gitconfig(profile: Profile) -> str:
+    """Gera o conteúdo de ~/.gitconfig-<contexto>."""
+    lines = ["# Gerado pelo aparta — perfil: " + profile.name, "[user]"]
+    if profile.git_name:
+        lines.append(f"\tname = {profile.git_name}")
+    lines.append(f"\temail = {profile.git_email}")
+    if profile.ssh_key:
+        key = profile.ssh_key
+        lines += [
+            "[core]",
+            f'\tsshCommand = ssh -i {key} -o IdentitiesOnly=yes',
+        ]
+    if profile.ssh_alias:
+        lines += [
+            f'[url "git@{profile.ssh_alias}:"]',
+            "\tinsteadOf = https://github.com/",
+            "\tinsteadOf = git@github.com:",
+        ]
+    return "\n".join(lines) + "\n"
+
+
+def gitdir_pattern(profile: Profile) -> str:
+    """Padrão gitdir com ~ preservado quando a raiz está sob a home."""
+    root = str(profile.root_path)
+    home = str(Path.home())
+    if root.startswith(home):
+        root = "~" + root[len(home):]
+    if not root.endswith("/"):
+        root += "/"
+    return root
+
+
+def render_includeif_block(gitdir: str, include_path: str) -> str:
+    return f'[includeIf "gitdir:{gitdir}"]\n\tpath = {include_path}\n'
+
+
+def has_includeif(gitconfig_text: str, gitdir: str) -> bool:
+    """True se já existe um bloco includeIf para este gitdir."""
+    pattern = re.compile(
+        r'\[includeIf\s+"gitdir:' + re.escape(gitdir) + r'"\]', re.IGNORECASE
+    )
+    return bool(pattern.search(gitconfig_text))
+
+
+def merge_includeif(gitconfig_text: str, gitdir: str, include_path: str) -> str:
+    """Adiciona o bloco includeIf apenas se ausente; preserva todo o resto."""
+    if has_includeif(gitconfig_text, gitdir):
+        return gitconfig_text
+    block = render_includeif_block(gitdir, include_path)
+    if gitconfig_text and not gitconfig_text.endswith("\n"):
+        gitconfig_text += "\n"
+    sep = "\n" if gitconfig_text else ""
+    return gitconfig_text + sep + block
+
+
+def apply_git(profile: Profile, writer: SafeWriter, home: Path | None = None) -> None:
+    """Escreve ~/.gitconfig-<contexto> e faz merge do includeIf no ~/.gitconfig."""
+    home = home or Path.home()
+    ctx_path = context_gitconfig_path(profile, home)
+    writer.write_text(ctx_path, render_context_gitconfig(profile))
+
+    gitconfig = home / ".gitconfig"
+    existing = gitconfig.read_text() if gitconfig.exists() else ""
+    include_path = str(ctx_path)
+    if include_path.startswith(str(home)):
+        include_path = "~" + include_path[len(str(home)):]
+    merged = merge_includeif(existing, gitdir_pattern(profile), include_path)
+    if merged != existing:
+        writer.write_text(gitconfig, merged)