pep-agentes 1.2.0__py3-none-any.whl

pep/__init__.py

@@ -0,0 +1,5 @@
+"""PEP-Agentes Manager core package."""
+
+from pep.core.version import __version__
+
+__all__ = ["__version__"]

pep/cli.py

@@ -0,0 +1,69 @@
+"""Console entrypoint for the PEP-Agentes Manager."""
+
+from __future__ import annotations
+
+import argparse
+
+from pep.core.version import __version__
+from pep.services.manager import (
+    collect_doctor,
+    collect_status,
+    format_results,
+    format_status,
+    resolve_scopes,
+    run_operation,
+)
+
+PROVIDERS = ("claude", "codex", "all")
+
+
+def add_scope_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--here", action="store_true", help="usar o diretorio atual")
+    parser.add_argument("--path", action="append", metavar="CAMINHO", help="usar um projeto especifico")
+    parser.add_argument("--global", dest="global_scope", action="store_true", help="usar instalacao global")
+    parser.add_argument("--legacy-prompt", action="store_true", help="incluir /prompts:pepcodex para Codex")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="PEP-Agentes Manager")
+    sub = parser.add_subparsers(dest="command", required=True)
+    for command in ("install", "update", "uninstall", "repair", "status"):
+        p = sub.add_parser(command)
+        p.add_argument("provider", nargs="?", default="all", choices=PROVIDERS)
+        add_scope_args(p)
+        if command in {"install", "update"}:
+            p.add_argument("--force", action="store_true", help="sobrescrever arquivos gerenciados")
+    p = sub.add_parser("doctor")
+    p.add_argument("provider", nargs="?", default="all", choices=PROVIDERS)
+    add_scope_args(p)
+    sub.add_parser("version")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    if args.command == "version":
+        print(__version__)
+        return 0
+
+    scopes = resolve_scopes(args.here, args.path, args.global_scope)
+    if not scopes:
+        print("Nenhum alvo selecionado. Use --here, --path CAMINHO ou --global.")
+        return 2
+
+    if args.command == "status":
+        print(format_status(collect_status(args.provider, scopes, args.legacy_prompt)))
+        return 0
+    if args.command == "doctor":
+        print(collect_doctor(args.provider, scopes, args.legacy_prompt))
+        return 0
+
+    results = run_operation(
+        args.command,
+        args.provider,
+        scopes,
+        force=getattr(args, "force", False),
+        legacy_prompt=args.legacy_prompt,
+    )
+    print(format_results(results))
+    return 0

pep/core/__init__.py

@@ -0,0 +1 @@
+"""Core utilities for PEP-Agentes Manager."""

pep/core/detection.py

@@ -0,0 +1,47 @@
+"""Local-only tool detection used by doctor/status."""
+
+from __future__ import annotations
+
+import importlib.util
+import platform
+import shutil
+import sys
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ToolStatus:
+    name: str
+    found: bool
+    detail: str
+
+
+def detect_command(name: str, command: str) -> ToolStatus:
+    path = shutil.which(command)
+    return ToolStatus(name, bool(path), path or "nao encontrado no PATH")
+
+
+def detect_python() -> ToolStatus:
+    return ToolStatus("Python", True, sys.version.split()[0])
+
+
+def detect_system() -> ToolStatus:
+    return ToolStatus("Sistema", True, f"{platform.system()} {platform.release()}".strip())
+
+
+def detect_genpyexe() -> ToolStatus:
+    if importlib.util.find_spec("genpyexeks"):
+        return ToolStatus("GenPyEXE", True, "modulo genpyexeks disponivel")
+    path = shutil.which("genpyexe")
+    return ToolStatus("GenPyEXE", bool(path), path or "instale com: pip install genpyexe")
+
+
+def doctor_tools() -> list[ToolStatus]:
+    return [
+        detect_system(),
+        detect_python(),
+        detect_command("Git", "git"),
+        detect_command("Claude Code", "claude"),
+        detect_command("Codex", "codex"),
+        detect_genpyexe(),
+    ]

pep/core/markers.py

@@ -0,0 +1,66 @@
+"""Marker-managed Markdown block operations."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+
+class MarkerError(RuntimeError):
+    """Raised when a managed marker block is malformed."""
+
+
+def _has_broken_markers(text: str, start: str, end: str, pattern: re.Pattern[str]) -> bool:
+    starts = text.count(start)
+    ends = text.count(end)
+    if starts != ends:
+        return True
+    return starts > 0 and not pattern.search(text)
+
+
+def read_managed_block(source: Path, pattern: re.Pattern[str]) -> str:
+    text = source.read_text(encoding="utf-8")
+    match = pattern.search(text)
+    if not match:
+        raise MarkerError(f"Marcadores PEP nao encontrados em {source}")
+    return match.group(0)
+
+
+def upsert_block(path: Path, block: str, pattern: re.Pattern[str], start: str, end: str, header: str) -> str:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists():
+        current = path.read_text(encoding="utf-8")
+        if _has_broken_markers(current, start, end, pattern):
+            raise MarkerError(f"Markers corrompidos em {path}")
+        if pattern.search(current):
+            path.write_text(pattern.sub(lambda _: block, current), encoding="utf-8")
+            return "atualizado"
+        sep = "" if current.endswith("\n") else "\n"
+        path.write_text(f"{current}{sep}\n{block}\n", encoding="utf-8")
+        return "bloco adicionado"
+    path.write_text(f"{header}{block}\n", encoding="utf-8")
+    return "criado"
+
+
+def remove_block(path: Path, pattern: re.Pattern[str], start: str, end: str) -> str:
+    if not path.exists():
+        return "inexistente"
+    current = path.read_text(encoding="utf-8")
+    if _has_broken_markers(current, start, end, pattern):
+        raise MarkerError(f"Markers corrompidos em {path}")
+    if not pattern.search(current):
+        return "sem bloco"
+    path.write_text(pattern.sub("", current).rstrip() + "\n", encoding="utf-8")
+    return "bloco removido"
+
+
+def block_state(path: Path, expected: str, pattern: re.Pattern[str], start: str, end: str) -> str:
+    if not path.exists():
+        return "missing"
+    current = path.read_text(encoding="utf-8")
+    if _has_broken_markers(current, start, end, pattern):
+        return "corrupt"
+    match = pattern.search(current)
+    if not match:
+        return "missing"
+    return "current" if match.group(0) == expected else "outdated"

pep/core/models.py

@@ -0,0 +1,41 @@
+"""Small data models used by providers and services."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+
+class InstallState(str, Enum):
+    NOT_INSTALLED = "not_installed"
+    INSTALLED = "installed"
+    CURRENT = "current"
+    OUTDATED = "outdated"
+    PARTIAL = "partial"
+    CORRUPT = "corrupt"
+
+
+@dataclass(frozen=True)
+class Scope:
+    path: Path
+    is_global: bool = False
+
+    @property
+    def label(self) -> str:
+        return "GLOBAL" if self.is_global else str(self.path)
+
+
+@dataclass(frozen=True)
+class Status:
+    provider: str
+    scope: Scope
+    state: InstallState
+    detail: str
+
+
+@dataclass(frozen=True)
+class OperationResult:
+    provider: str
+    scope: Scope
+    messages: tuple[str, ...]

pep/core/paths.py

@@ -0,0 +1,27 @@
+"""Path helpers shared by CLI, GUI and providers."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def package_root() -> Path:
+    """Return the project/resource root, supporting PyInstaller onefile."""
+    if getattr(sys, "frozen", False):
+        return Path(getattr(sys, "_MEIPASS", Path(sys.executable).resolve().parent))
+    source_root = Path(__file__).resolve().parents[2]
+    if (source_root / "claude").exists() and (source_root / "codex").exists():
+        return source_root
+    installed_root = Path(sys.prefix) / "share" / "pep-agentes"
+    if installed_root.exists():
+        return installed_root
+    return source_root
+
+
+def user_home() -> Path:
+    return Path.home()
+
+
+def prompt_path(relative: str) -> Path:
+    return package_root() / relative

pep/core/version.py

@@ -0,0 +1,5 @@
+"""Single version source for PEP-Agentes."""
+
+__version__ = "1.2.0"
+APP_NAME = "PEP-Agentes"
+APP_TITLE = f"{APP_NAME} v{__version__}"

pep/providers/__init__.py

@@ -0,0 +1,24 @@
+"""Provider registry for PEP-Agentes Manager."""
+
+from __future__ import annotations
+
+from pep.providers.claude import ClaudeProvider
+from pep.providers.codex import CodexProvider
+
+
+PROVIDERS = {
+    "claude": ClaudeProvider(),
+    "codex": CodexProvider(),
+}
+
+
+def get_provider(name: str):
+    if name not in PROVIDERS:
+        raise ValueError(f"Provider desconhecido: {name}")
+    return PROVIDERS[name]
+
+
+def selected_providers(name: str):
+    if name == "all":
+        return list(PROVIDERS.values())
+    return [get_provider(name)]

pep/providers/base.py

@@ -0,0 +1,23 @@
+"""Provider protocol shared by Claude and Codex adapters."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Protocol
+
+from pep.core.models import OperationResult, Scope, Status
+
+
+class Provider(Protocol):
+    name: str
+    display_name: str
+
+    def prompt_path(self) -> Path | None: ...
+
+    def install(self, scope: Scope, force: bool = False, legacy_prompt: bool = False) -> OperationResult: ...
+
+    def uninstall(self, scope: Scope, legacy_prompt: bool = False) -> OperationResult: ...
+
+    def status(self, scope: Scope, legacy_prompt: bool = False) -> Status: ...
+
+    def repair(self, scope: Scope, legacy_prompt: bool = False) -> OperationResult: ...

pep/providers/claude.py

@@ -0,0 +1,101 @@
+"""Claude Code provider adapter."""
+
+from __future__ import annotations
+
+import re
+import shutil
+from pathlib import Path
+
+from pep.core import paths
+from pep.core.markers import block_state, read_managed_block, remove_block, upsert_block
+from pep.core.models import InstallState, OperationResult, Scope, Status
+
+START = "<!-- PEP-AGENTES:START"
+END = "<!-- PEP-AGENTES:END -->"
+BLOCK_RE = re.compile(r"<!-- PEP-AGENTES:START.*?<!-- PEP-AGENTES:END -->", re.DOTALL)
+HEADER = (
+    "# Instrucoes do projeto (Claude Code)\n\n"
+    "Bloco PEP-Agentes gerenciado por scripts/install_claude.py (nao edite entre os marcadores).\n\n"
+)
+
+
+class ClaudeProvider:
+    name = "claude"
+    display_name = "Claude Code"
+
+    @property
+    def source_claude_md(self) -> Path:
+        return paths.package_root() / "claude" / "CLAUDE.md"
+
+    @property
+    def source_command(self) -> Path:
+        return paths.package_root() / "claude" / "commands" / "pep.md"
+
+    def prompt_path(self) -> Path:
+        return paths.package_root() / "prompts" / "pep-agentes-claude.txt"
+
+    def block(self) -> str:
+        return read_managed_block(self.source_claude_md, BLOCK_RE)
+
+    def command_text(self) -> str:
+        return self.source_command.read_text(encoding="utf-8")
+
+    def targets_for(self, scope: Scope) -> tuple[Path, Path]:
+        if scope.is_global:
+            base = scope.path
+            return base / "CLAUDE.md", base / "commands" / "pep.md"
+        return scope.path / "CLAUDE.md", scope.path / ".claude" / "commands" / "pep.md"
+
+    def install(self, scope: Scope, force: bool = False, legacy_prompt: bool = False) -> OperationResult:
+        del legacy_prompt
+        claude_md, command_path = self.targets_for(scope)
+        block = self.block()
+        command_text = self.command_text()
+        messages = [f"CLAUDE.md: {upsert_block(claude_md, block, BLOCK_RE, START, END, HEADER)} -> {claude_md}"]
+        command_path.parent.mkdir(parents=True, exist_ok=True)
+        if command_path.exists() and not force:
+            if command_path.read_text(encoding="utf-8") == command_text:
+                messages.append(f"/pep: ja atualizado -> {command_path}")
+            else:
+                messages.append(f"/pep: JA EXISTE (use --force para sobrescrever) -> {command_path}")
+        else:
+            command_path.write_text(command_text, encoding="utf-8")
+            messages.append(f"/pep: instalado -> {command_path}")
+        return OperationResult(self.name, scope, tuple(messages))
+
+    def uninstall(self, scope: Scope, legacy_prompt: bool = False) -> OperationResult:
+        del legacy_prompt
+        claude_md, command_path = self.targets_for(scope)
+        messages = [f"CLAUDE.md: {remove_block(claude_md, BLOCK_RE, START, END)} -> {claude_md}"]
+        if command_path.exists():
+            command_path.unlink()
+            messages.append(f"/pep: removido -> {command_path}")
+        else:
+            messages.append(f"/pep: inexistente -> {command_path}")
+        return OperationResult(self.name, scope, tuple(messages))
+
+    def status(self, scope: Scope, legacy_prompt: bool = False) -> Status:
+        del legacy_prompt
+        claude_md, command_path = self.targets_for(scope)
+        block = self.block()
+        md_state = block_state(claude_md, block, BLOCK_RE, START, END)
+        command_ok = command_path.exists() and command_path.read_text(encoding="utf-8") == self.command_text()
+        if md_state == "corrupt":
+            state = InstallState.CORRUPT
+        elif md_state == "missing" and not command_path.exists():
+            state = InstallState.NOT_INSTALLED
+        elif md_state == "current" and command_ok:
+            state = InstallState.CURRENT
+        elif md_state == "outdated" or (command_path.exists() and not command_ok):
+            state = InstallState.OUTDATED
+        else:
+            state = InstallState.PARTIAL
+        return Status(self.name, scope, state, f"CLAUDE.md={md_state}; command={'ok' if command_ok else 'missing/outdated'}")
+
+    def repair(self, scope: Scope, legacy_prompt: bool = False) -> OperationResult:
+        status = self.status(scope, legacy_prompt)
+        if status.state == InstallState.CURRENT:
+            return OperationResult(self.name, scope, ("Claude Code ja esta atualizado.",))
+        if status.state == InstallState.CORRUPT:
+            return OperationResult(self.name, scope, ("Markers corrompidos; reparo automatico cancelado para preservar conteudo manual.",))
+        return self.install(scope, force=True)

pep/providers/codex.py

@@ -0,0 +1,131 @@
+"""Codex provider adapter."""
+
+from __future__ import annotations
+
+import filecmp
+import re
+import shutil
+from pathlib import Path
+
+from pep.core import paths
+from pep.core.markers import block_state, read_managed_block, remove_block, upsert_block
+from pep.core.models import InstallState, OperationResult, Scope, Status
+
+START = "<!-- PEP-CODEX:START"
+END = "<!-- PEP-CODEX:END -->"
+BLOCK_RE = re.compile(r"<!-- PEP-CODEX:START.*?<!-- PEP-CODEX:END -->", re.DOTALL)
+HEADER = (
+    "# Instrucoes do projeto (Codex)\n\n"
+    "Bloco PEP-Codex gerenciado por scripts/install_codex.py.\n\n"
+)
+
+
+class CodexProvider:
+    name = "codex"
+    display_name = "Codex"
+
+    @property
+    def source_agents(self) -> Path:
+        return paths.package_root() / "codex" / "AGENTS.md"
+
+    @property
+    def source_skill(self) -> Path:
+        return paths.package_root() / "codex" / "skills" / "pepcodex"
+
+    @property
+    def source_prompt(self) -> Path:
+        return paths.package_root() / "codex" / "prompts" / "pepcodex.md"
+
+    def prompt_path(self) -> Path:
+        return self.source_prompt
+
+    def block(self) -> str:
+        return read_managed_block(self.source_agents, BLOCK_RE)
+
+    def targets_for(self, scope: Scope) -> tuple[Path, Path]:
+        if scope.is_global:
+            return scope.path / "AGENTS.md", paths.user_home() / ".agents" / "skills" / "pepcodex"
+        return scope.path / "AGENTS.md", scope.path / ".agents" / "skills" / "pepcodex"
+
+    def legacy_prompt_target(self) -> Path:
+        return paths.user_home() / ".codex" / "prompts" / "pepcodex.md"
+
+    def _copy_skill(self, dest: Path, force: bool) -> str:
+        if dest.exists():
+            if not force:
+                return "ja existe (use --force para atualizar)"
+            shutil.rmtree(dest)
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(self.source_skill, dest)
+        return "instalada"
+
+    def _skill_matches(self, dest: Path) -> bool:
+        if not dest.exists():
+            return False
+        src_files = sorted(p.relative_to(self.source_skill) for p in self.source_skill.rglob("*") if p.is_file())
+        dst_files = sorted(p.relative_to(dest) for p in dest.rglob("*") if p.is_file())
+        if src_files != dst_files:
+            return False
+        return all(filecmp.cmp(self.source_skill / rel, dest / rel, shallow=False) for rel in src_files)
+
+    def install(self, scope: Scope, force: bool = False, legacy_prompt: bool = False) -> OperationResult:
+        agents, skill = self.targets_for(scope)
+        messages = [f"AGENTS.md: {upsert_block(agents, self.block(), BLOCK_RE, START, END, HEADER)} -> {agents}"]
+        messages.append(f"$pepcodex: {self._copy_skill(skill, force)} -> {skill}")
+        if legacy_prompt:
+            dest = self.legacy_prompt_target()
+            if dest.exists() and not force:
+                messages.append(f"/prompts:pepcodex: ja existe (use --force para atualizar) -> {dest}")
+            else:
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(self.source_prompt, dest)
+                messages.append(f"/prompts:pepcodex: instalado -> {dest}")
+        return OperationResult(self.name, scope, tuple(messages))
+
+    def uninstall(self, scope: Scope, legacy_prompt: bool = False) -> OperationResult:
+        agents, skill = self.targets_for(scope)
+        messages = [f"AGENTS.md: {remove_block(agents, BLOCK_RE, START, END)} -> {agents}"]
+        if skill.exists():
+            shutil.rmtree(skill)
+            messages.append(f"$pepcodex: removida -> {skill}")
+        else:
+            messages.append(f"$pepcodex: inexistente -> {skill}")
+        if legacy_prompt:
+            dest = self.legacy_prompt_target()
+            if dest.exists():
+                dest.unlink()
+                messages.append(f"/prompts:pepcodex: removido -> {dest}")
+            else:
+                messages.append(f"/prompts:pepcodex: inexistente -> {dest}")
+        return OperationResult(self.name, scope, tuple(messages))
+
+    def status(self, scope: Scope, legacy_prompt: bool = False) -> Status:
+        agents, skill = self.targets_for(scope)
+        md_state = block_state(agents, self.block(), BLOCK_RE, START, END)
+        skill_ok = self._skill_matches(skill)
+        legacy_ok = True
+        if legacy_prompt:
+            dest = self.legacy_prompt_target()
+            legacy_ok = dest.exists() and filecmp.cmp(self.source_prompt, dest, shallow=False)
+        if md_state == "corrupt":
+            state = InstallState.CORRUPT
+        elif md_state == "missing" and not skill.exists():
+            state = InstallState.NOT_INSTALLED
+        elif md_state == "current" and skill_ok and legacy_ok:
+            state = InstallState.CURRENT
+        elif md_state == "outdated" or (skill.exists() and not skill_ok) or not legacy_ok:
+            state = InstallState.OUTDATED
+        else:
+            state = InstallState.PARTIAL
+        detail = f"AGENTS.md={md_state}; skill={'ok' if skill_ok else 'missing/outdated'}"
+        if legacy_prompt:
+            detail += f"; legacy={'ok' if legacy_ok else 'missing/outdated'}"
+        return Status(self.name, scope, state, detail)
+
+    def repair(self, scope: Scope, legacy_prompt: bool = False) -> OperationResult:
+        status = self.status(scope, legacy_prompt)
+        if status.state == InstallState.CURRENT:
+            return OperationResult(self.name, scope, ("Codex ja esta atualizado.",))
+        if status.state == InstallState.CORRUPT:
+            return OperationResult(self.name, scope, ("Markers corrompidos; reparo automatico cancelado para preservar conteudo manual.",))
+        return self.install(scope, force=True, legacy_prompt=legacy_prompt)

pep/services/__init__.py

@@ -0,0 +1 @@
+"""Service layer for PEP-Agentes Manager."""

pep/services/manager.py

@@ -0,0 +1,93 @@
+"""High-level operations shared by CLI and GUI."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pep.core.detection import doctor_tools
+from pep.core.models import OperationResult, Scope, Status
+from pep.providers import selected_providers
+
+
+def resolve_scopes(here: bool = False, paths: list[str] | None = None, global_scope: bool = False) -> list[Scope]:
+    scopes: list[Scope] = []
+    if here:
+        scopes.append(Scope(Path.cwd(), False))
+    for raw in paths or []:
+        scopes.append(Scope(Path(raw).expanduser().resolve(), False))
+    if global_scope:
+        from pep.core.paths import user_home
+
+        scopes.append(Scope(user_home() / ".codex", True))
+    return scopes
+
+
+def resolve_provider_scope(provider_name: str, scope: Scope) -> Scope:
+    if not scope.is_global:
+        return scope
+    from pep.core.paths import user_home
+
+    if provider_name == "claude":
+        return Scope(user_home() / ".claude", True)
+    if provider_name == "codex":
+        return Scope(user_home() / ".codex", True)
+    return scope
+
+
+def run_operation(
+    action: str,
+    provider_name: str,
+    scopes: list[Scope],
+    force: bool = False,
+    legacy_prompt: bool = False,
+) -> list[OperationResult]:
+    results: list[OperationResult] = []
+    for provider in selected_providers(provider_name):
+        for scope in scopes:
+            provider_scope = resolve_provider_scope(provider.name, scope)
+            if action in {"install", "update"}:
+                results.append(provider.install(provider_scope, force=force or action == "update", legacy_prompt=legacy_prompt))
+            elif action == "uninstall":
+                results.append(provider.uninstall(provider_scope, legacy_prompt=legacy_prompt))
+            elif action == "repair":
+                results.append(provider.repair(provider_scope, legacy_prompt=legacy_prompt))
+            else:
+                raise ValueError(f"Acao desconhecida: {action}")
+    return results
+
+
+def collect_status(provider_name: str, scopes: list[Scope], legacy_prompt: bool = False) -> list[Status]:
+    rows: list[Status] = []
+    for provider in selected_providers(provider_name):
+        for scope in scopes:
+            rows.append(provider.status(resolve_provider_scope(provider.name, scope), legacy_prompt=legacy_prompt))
+    return rows
+
+
+def collect_doctor(provider_name: str = "all", scopes: list[Scope] | None = None, legacy_prompt: bool = False) -> str:
+    lines = ["PEP Doctor", ""]
+    for tool in doctor_tools():
+        status = "OK" if tool.found else "ERRO"
+        lines.append(f"{tool.name:.<22} {status} - {tool.detail}")
+    if scopes:
+        lines.append("")
+        for row in collect_status(provider_name, scopes, legacy_prompt=legacy_prompt):
+            lines.append(f"{row.provider} {row.scope.label}: {row.state.value} - {row.detail}")
+    return "\n".join(lines)
+
+
+def format_results(results: list[OperationResult]) -> str:
+    chunks: list[str] = []
+    for result in results:
+        chunks.append(f"== {result.provider} | {result.scope.label} ==")
+        chunks.extend(result.messages)
+        chunks.append("")
+    chunks.append("Concluido.")
+    return "\n".join(chunks)
+
+
+def format_status(rows: list[Status]) -> str:
+    lines = []
+    for row in rows:
+        lines.append(f"{row.provider} | {row.scope.label}: {row.state.value} - {row.detail}")
+    return "\n".join(lines) if lines else "Nenhum alvo selecionado."