neo-cmd 0.1.0__py3-none-any.whl

neo/__init__.py

@@ -0,0 +1,2 @@
+def hello() -> str:
+    return "Hello from neo!"

neo/cli.py

@@ -0,0 +1,76 @@
+"""Entrypoint principal da CLI Neo."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import typer
+from rich import print as rprint
+
+from neo.commands.config import config_app
+from neo.commands.git import git_app
+from neo.commands.tasks import tasks_app
+
+__version__ = "0.1.0"
+
+
+@dataclass
+class AppContext:
+    json_mode: bool = False
+    verbose: bool = False
+
+
+app = typer.Typer(
+    name="neo",
+    help="""[bold cyan]Neo — Personal Command Assistant[/bold cyan]
+
+Compreenda seus sistemas. Seja dono das suas escolhas.
+
+Centraliza operações de trabalho (Bitbucket, Shortcut) e vida pessoal,
+investigando dados com autonomia e sem atrito.
+""",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+# Registra subcomandos
+app.add_typer(config_app, name="config")
+app.add_typer(git_app, name="git")
+app.add_typer(tasks_app, name="tasks")
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        rprint(f"[bold cyan]Neo[/bold cyan] v{__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    version: bool | None = typer.Option(
+        None,
+        "--version",
+        "-V",
+        help="Exibe a versão do Neo e encerra.",
+        callback=version_callback,
+        is_eager=True,
+    ),
+    json_mode: bool = typer.Option(
+        False,
+        "--json",
+        help="Emite a saída em formato JSON estruturado no stdout.",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Habilita mensagens de debug e detalhes de rede.",
+    ),
+) -> None:
+    """Configura o contexto global da aplicação."""
+    ctx.obj = AppContext(json_mode=json_mode, verbose=verbose)
+
+
+if __name__ == "__main__":
+    app()

neo/commands/__init__.py

@@ -0,0 +1 @@
+"""Comandos da CLI do Neo."""

neo/commands/_credentials.py

@@ -0,0 +1,105 @@
+"""Operações de credenciais compartilhadas por `neo git config auth` e `neo tasks config`."""
+
+from __future__ import annotations
+
+import typer
+from keyring.errors import KeyringError
+
+from neo.config import (
+    delete_credential,
+    get_credential,
+    get_credential_source,
+    mask_token,
+    set_credential,
+)
+from neo.output import print_error, print_json, print_panel, print_success
+
+
+def is_json_mode(ctx: typer.Context) -> bool:
+    return getattr(ctx.obj, "json_mode", False) if ctx.obj else False
+
+
+def save_token(ctx: typer.Context, svc: str, token: str | None) -> None:
+    """Grava o token de `svc` (prompt oculto se `token` for omitido)."""
+    as_json = is_json_mode(ctx)
+
+    if not token:
+        if as_json:
+            print_error(
+                "A flag --token é obrigatória quando o modo --json está ativo.",
+                as_json=True,
+                code=1,
+            )
+            raise typer.Exit(code=1)
+        token = typer.prompt(f"Digite o token para '{svc}'", hide_input=True)
+
+    try:
+        set_credential(svc, token)
+        source = get_credential_source(svc)
+        print_success(
+            f"Token para o serviço '{svc}' configurado com sucesso (armazenado via {source})!",
+            as_json=as_json,
+            json_payload={"status": "success", "service": svc, "source": source},
+        )
+    except (KeyringError, OSError, RuntimeError, ValueError) as e:
+        print_error(f"Falha ao salvar credencial: {e}", as_json=as_json, code=1)
+        raise typer.Exit(code=1) from e
+
+
+def show_token(ctx: typer.Context, svc: str) -> None:
+    """Exibe o status e o token mascarado de `svc`."""
+    as_json = is_json_mode(ctx)
+    token = get_credential(svc)
+    source = get_credential_source(svc)
+
+    if not token:
+        print_error(
+            f"Serviço '{svc}' não possui credenciais configuradas.",
+            as_json=as_json,
+            json_payload={
+                "service": svc,
+                "configured": False,
+                "source": None,
+                "masked_token": None,
+            },
+            code=1,
+        )
+        raise typer.Exit(code=1)
+
+    masked = mask_token(token)
+    if as_json:
+        print_json(
+            {
+                "service": svc,
+                "configured": True,
+                "source": source,
+                "masked_token": masked,
+            }
+        )
+    else:
+        print_panel(
+            f"Autenticação: {svc}",
+            f"[bold]Status:[/bold] [green]Configurado[/green]\n"
+            f"[bold]Origem:[/bold] {source}\n"
+            f"[bold]Token:[/bold] {masked}",
+        )
+
+
+def remove_token(ctx: typer.Context, svc: str) -> None:
+    """Remove a credencial armazenada de `svc`."""
+    as_json = is_json_mode(ctx)
+
+    if delete_credential(svc):
+        print_success(
+            f"Credencial para o serviço '{svc}' removida com sucesso.",
+            as_json=as_json,
+            json_payload={"status": "success", "service": svc, "deleted": True},
+        )
+    else:
+        print_error(
+            f"Nenhuma credencial encontrada para remover no serviço '{svc}'.",
+            as_json=as_json,
+            json_payload={"status": "error", "service": svc, "deleted": False},
+            code=1,
+        )
+        raise typer.Exit(code=1)

neo/commands/commits.py

@@ -0,0 +1,95 @@
+"""Comandos de consulta e histórico de commits Git (Bitbucket e GitHub) (`neo git commits`)."""
+
+from __future__ import annotations
+
+import typer
+from typer import Option
+
+from neo.integrations.bitbucket import BitbucketError
+from neo.integrations.resolver import (
+    detect_git_remote_info,
+    resolve_git_provider,
+)
+from neo.output import print_error, print_json, print_panel, print_table
+
+commits_app = typer.Typer(
+    name="commits",
+    help="Histórico e pesquisa de commits no Bitbucket e GitHub.",
+    no_args_is_help=True,
+)
+
+
+def _infer_repo_slug_from_git() -> str | None:
+    """Tenta inferir o slug do repositório a partir do remote origin do diretório local."""
+    return detect_git_remote_info()[1]
+
+
+@commits_app.command("search")
+def commits_search(
+    ctx: typer.Context,
+    repo: str | None = Option(
+        None, "--repo", "-r", help="Slug do repositório (inferido do git local se omitido)."
+    ),
+    workspace: str | None = Option(
+        None, "--workspace", "-w", help="Workspace ou organização/usuário de destino."
+    ),
+    provider: str | None = Option(
+        None, "--provider", "-p", help="Provedor Git: 'bitbucket' ou 'github'."
+    ),
+    author: str | None = Option(None, "--author", "-a", help="Filtra por nome ou e-mail do autor."),
+    query: str | None = Option(
+        None, "--query", "-q", help="Filtra por termo na mensagem do commit."
+    ),
+    limit: int = Option(20, "--limit", "-l", help="Quantidade máxima de commits a retornar."),
+) -> None:
+    """Pesquisa commits em um repositório no Bitbucket ou GitHub."""
+    as_json = getattr(ctx.obj, "json_mode", False) if ctx.obj else False
+
+    target_repo = repo or _infer_repo_slug_from_git()
+    if not target_repo:
+        msg = (
+            "Repositório não informado e não foi possível inferir do git local. "
+            "Use a flag `--repo <slug>` para especificar o repositório."
+        )
+        print_error(msg, as_json=as_json, code=1)
+        raise typer.Exit(code=1)
+
+    prov_name, client = resolve_git_provider(provider, as_json=as_json)
+
+    try:
+        commits = client.list_commits(
+            repo_slug=target_repo,
+            workspace=workspace,
+            author=author,
+            query=query,
+            limit=limit,
+        )
+    except BitbucketError as e:
+        print_error(str(e), as_json=as_json, code=1)
+        raise typer.Exit(code=1) from e
+
+    if as_json:
+        print_json([c.model_dump() for c in commits])
+    else:
+        prov_title = "GitHub" if prov_name == "github" else "Bitbucket"
+        if not commits:
+            print_panel(
+                "Commits",
+                f"Nenhum commit encontrado para os filtros informados em '{target_repo}' ({prov_title}).",
+            )
+            return
+
+        columns = ["Hash", "Autor", "Data", "Mensagem"]
+        rows: list[list[str]] = []
+        for c in commits:
+            date_str = c.date.split("T")[0] if "T" in c.date else c.date
+            rows.append(
+                [
+                    f"[bold yellow]{c.short_hash}[/bold yellow]",
+                    c.author.author_name,
+                    date_str,
+                    c.summary,
+                ]
+            )
+
+        print_table(f"Histórico de Commits ({target_repo} via {prov_title})", columns, rows)

neo/commands/config.py

@@ -0,0 +1,58 @@
+"""Comandos de visão geral das configurações do Neo (`neo config`).
+
+A configuração de credenciais fica em `neo git config` (Bitbucket/GitHub) e
+`neo tasks config` (Shortcut).
+"""
+
+from __future__ import annotations
+
+import typer
+
+from neo.commands._credentials import is_json_mode
+from neo.config import (
+    DEFAULT_CONFIG_FILE,
+    get_all_services_status,
+    get_default_provider_config,
+)
+from neo.output import print_json, print_panel, print_table
+
+config_app = typer.Typer(
+    name="config",
+    help="Visão geral das configurações do Neo (credenciais: `neo git config` e `neo tasks config`).",
+    no_args_is_help=True,
+)
+
+
+@config_app.command("show")
+def config_show(ctx: typer.Context) -> None:
+    """Exibe o status geral das configurações e credenciais do Neo."""
+    as_json = is_json_mode(ctx)
+    statuses = get_all_services_status()
+    default_provider = get_default_provider_config() or "bitbucket"
+
+    if as_json:
+        print_json(
+            {
+                "config_file": str(DEFAULT_CONFIG_FILE),
+                "default_provider": default_provider,
+                "services": statuses,
+            }
+        )
+    else:
+        columns = ["Serviço", "Status", "Origem", "Token Mascarado"]
+        rows: list[list[str]] = []
+        for svc, info in statuses.items():
+            status_str = (
+                "[bold green]Configurado[/bold green]"
+                if info["configured"]
+                else "[dim]Não configurado[/dim]"
+            )
+            source_str = str(info["source"]) if info["source"] else "-"
+            token_str = str(info["masked_token"]) if info["masked_token"] else "-"
+            rows.append([svc, status_str, source_str, token_str])
+
+        print_table("Status de Autenticação do Neo", columns, rows)
+        print_panel(
+            "Provedor Git Ativo",
+            f"[bold]Provedor padrão:[/bold] [cyan]{default_provider}[/cyan]",
+        )

neo/commands/git.py

@@ -0,0 +1,134 @@
+"""Guarda-chuva dos comandos Git (Bitbucket e GitHub) (`neo git`)."""
+
+from __future__ import annotations
+
+import typer
+from typer import Argument, Option
+
+from neo.commands._credentials import is_json_mode, remove_token, save_token, show_token
+from neo.commands.commits import commits_app
+from neo.commands.repo import repo_app
+from neo.commands.workspace import workspace_app
+from neo.config import (
+    SUPPORTED_GIT_PROVIDERS,
+    SUPPORTED_TASK_SERVICES,
+    GitProviderType,
+    get_default_provider_config,
+    set_default_provider_config,
+    validate_git_provider,
+)
+from neo.output import print_error, print_json, print_panel, print_success
+
+git_app = typer.Typer(
+    name="git",
+    help="Comandos Git unificados para Bitbucket e GitHub (config, workspace, repo, commits).",
+    no_args_is_help=True,
+)
+
+git_config_app = typer.Typer(
+    name="config",
+    help="Credenciais e provedor Git padrão (Bitbucket, GitHub).",
+    no_args_is_help=True,
+)
+
+auth_app = typer.Typer(
+    name="auth",
+    help="Gerencia tokens de autenticação dos provedores Git (Bitbucket, GitHub).",
+    no_args_is_help=True,
+)
+
+git_config_app.add_typer(auth_app, name="auth")
+git_app.add_typer(git_config_app, name="config")
+git_app.add_typer(workspace_app, name="workspace")
+git_app.add_typer(repo_app, name="repo")
+git_app.add_typer(commits_app, name="commits")
+
+
+def _validate_git_service(ctx: typer.Context, service: str) -> GitProviderType:
+    """Valida o serviço Git; `shortcut` é rejeitado com dica para `neo tasks config`."""
+    as_json = is_json_mode(ctx)
+    if service.strip().lower() in SUPPORTED_TASK_SERVICES:
+        print_error(
+            f"'{service}' é um serviço de tasks, não um provedor Git. "
+            f"Use `neo tasks config` para configurá-lo.",
+            as_json=as_json,
+            code=1,
+        )
+        raise typer.Exit(code=1)
+    try:
+        return validate_git_provider(service)
+    except ValueError as e:
+        print_error(str(e), as_json=as_json, code=1)
+        raise typer.Exit(code=1) from e
+
+
+@auth_app.command("set")
+def auth_set(
+    ctx: typer.Context,
+    service: str = Argument(
+        ..., help=f"Provedor para autenticar: {', '.join(SUPPORTED_GIT_PROVIDERS)}"
+    ),
+    token: str = Option(
+        None,
+        "--token",
+        "-t",
+        help="Token de acesso da API. Se omitido, solicita via prompt seguro.",
+    ),
+) -> None:
+    """Configura o token de autenticação de um provedor Git de forma segura."""
+    save_token(ctx, _validate_git_service(ctx, service), token)
+
+
+@auth_app.command("get")
+def auth_get(
+    ctx: typer.Context,
+    service: str = Argument(..., help=f"Provedor: {', '.join(SUPPORTED_GIT_PROVIDERS)}"),
+) -> None:
+    """Exibe o status e o token mascarado de um provedor Git."""
+    show_token(ctx, _validate_git_service(ctx, service))
+
+
+@auth_app.command("delete")
+def auth_delete(
+    ctx: typer.Context,
+    service: str = Argument(..., help=f"Provedor: {', '.join(SUPPORTED_GIT_PROVIDERS)}"),
+) -> None:
+    """Remove a credencial armazenada de um provedor Git."""
+    remove_token(ctx, _validate_git_service(ctx, service))
+
+
+@git_config_app.command("set-provider")
+def config_set_provider(
+    ctx: typer.Context,
+    provider: str = Argument(
+        ...,
+        help=f"Provedor Git padrão: {', '.join(SUPPORTED_GIT_PROVIDERS)}",
+    ),
+) -> None:
+    """Define o provedor Git padrão ('bitbucket' ou 'github') em config.toml."""
+    as_json = is_json_mode(ctx)
+
+    try:
+        prov = validate_git_provider(provider)
+    except ValueError as e:
+        print_error(str(e), as_json=as_json, code=1)
+        raise typer.Exit(code=1) from e
+
+    set_default_provider_config(prov)
+    print_success(
+        f"Provedor Git padrão definido com sucesso: [cyan]{prov}[/cyan]",
+        as_json=as_json,
+        json_payload={"status": "success", "default_provider": prov},
+    )
+
+
+@git_config_app.command("get-provider")
+def config_get_provider(ctx: typer.Context) -> None:
+    """Exibe o provedor Git padrão atualmente configurado."""
+    as_json = is_json_mode(ctx)
+    prov = get_default_provider_config() or "bitbucket (padrão implícito)"
+
+    if as_json:
+        print_json({"default_provider": get_default_provider_config()})
+    else:
+        print_panel("Provedor Git Padrão", f"[bold]Provedor:[/bold] [cyan]{prov}[/cyan]")

neo/commands/repo.py

@@ -0,0 +1,214 @@
+"""Comandos de gerenciamento de repositórios Git (Bitbucket e GitHub) (`neo git repo`)."""
+
+from __future__ import annotations
+
+import subprocess
+
+import typer
+from typer import Argument, Option
+
+from neo.integrations.bitbucket import (
+    BitbucketError,
+    BitbucketNotFoundError,
+)
+from neo.integrations.resolver import resolve_git_provider
+from neo.output import print_error, print_json, print_panel, print_success, print_table
+
+repo_app = typer.Typer(
+    name="repo",
+    help="Gerenciamento e busca de repositórios no Bitbucket e GitHub.",
+    no_args_is_help=True,
+)
+
+
+@repo_app.command("list")
+def repo_list(
+    ctx: typer.Context,
+    workspace: str | None = Option(
+        None, "--workspace", "-w", help="Workspace ou organização/usuário de destino."
+    ),
+    provider: str | None = Option(
+        None, "--provider", "-p", help="Provedor Git: 'bitbucket' ou 'github'."
+    ),
+) -> None:
+    """Lista todos os repositórios disponíveis no workspace ou organização."""
+    as_json = getattr(ctx.obj, "json_mode", False) if ctx.obj else False
+    prov_name, client = resolve_git_provider(provider, as_json=as_json)
+
+    try:
+        repos = client.list_repositories(workspace=workspace)
+    except BitbucketError as e:
+        print_error(str(e), as_json=as_json, code=1)
+        raise typer.Exit(code=1) from e
+
+    if as_json:
+        print_json([r.model_dump() for r in repos])
+    else:
+        if not repos:
+            print_panel("Repositórios", "Nenhum repositório encontrado no workspace informado.")
+            return
+
+        columns = ["Nome", "Slug", "Visibilidade", "Branch Padrão", "Atualizado em"]
+        rows: list[list[str]] = []
+        for r in repos:
+            vis = "[red]Privado[/red]" if r.is_private else "[green]Público[/green]"
+            updated = r.updated_on.split("T")[0] if "T" in r.updated_on else r.updated_on
+            rows.append([r.name, r.slug, vis, r.main_branch, updated])
+
+        prov_title = "GitHub" if prov_name == "github" else "Bitbucket"
+        print_table(f"Repositórios no {prov_title}", columns, rows)
+
+
+@repo_app.command("search")
+def repo_search(
+    ctx: typer.Context,
+    query: str = Argument(..., help="Termo de pesquisa (nome, slug ou descrição)."),
+    workspace: str | None = Option(
+        None, "--workspace", "-w", help="Workspace ou organização/usuário de destino."
+    ),
+    provider: str | None = Option(
+        None, "--provider", "-p", help="Provedor Git: 'bitbucket' ou 'github'."
+    ),
+) -> None:
+    """Pesquisa repositórios por nome, slug ou descrição."""
+    as_json = getattr(ctx.obj, "json_mode", False) if ctx.obj else False
+    prov_name, client = resolve_git_provider(provider, as_json=as_json)
+
+    try:
+        repos = client.search_repositories(query=query, workspace=workspace)
+    except BitbucketError as e:
+        print_error(str(e), as_json=as_json, code=1)
+        raise typer.Exit(code=1) from e
+
+    if as_json:
+        print_json([r.model_dump() for r in repos])
+    else:
+        if not repos:
+            print_panel(
+                f"Busca: '{query}'", "Nenhum repositório encontrado para o termo pesquisado."
+            )
+            return
+
+        columns = ["Nome", "Slug", "Visibilidade", "Descrição"]
+        rows: list[list[str]] = []
+        for r in repos:
+            vis = "[red]Privado[/red]" if r.is_private else "[green]Público[/green]"
+            desc = r.description or "-"
+            rows.append([r.name, r.slug, vis, desc])
+
+        prov_title = "GitHub" if prov_name == "github" else "Bitbucket"
+        print_table(f"Repositórios no {prov_title} encontrados para '{query}'", columns, rows)
+
+
+@repo_app.command("clone")
+def repo_clone(
+    ctx: typer.Context,
+    slug: str = Argument(..., help="Slug ou nome do repositório a clonar."),
+    workspace: str | None = Option(
+        None, "--workspace", "-w", help="Workspace ou organização/usuário de destino."
+    ),
+    provider: str | None = Option(
+        None, "--provider", "-p", help="Provedor Git: 'bitbucket' ou 'github'."
+    ),
+    use_ssh: bool = Option(False, "--ssh", help="Força clonagem via protocolo SSH."),
+    use_https: bool = Option(False, "--https", help="Força clonagem via protocolo HTTPS."),
+) -> None:
+    """Clona um repositório para o diretório atual."""
+    as_json = getattr(ctx.obj, "json_mode", False) if ctx.obj else False
+    prov_name, client = resolve_git_provider(provider, as_json=as_json)
+
+    try:
+        repo = client.get_repository(repo_slug=slug, workspace=workspace)
+    except BitbucketNotFoundError as e:
+        print_error(f"Repositório '{slug}' não encontrado: {e}", as_json=as_json, code=1)
+        raise typer.Exit(code=1) from e
+    except BitbucketError as e:
+        print_error(str(e), as_json=as_json, code=1)
+        raise typer.Exit(code=1) from e
+
+    # Resolução de URL
+    clone_url: str | None = None
+    if use_ssh:
+        clone_url = repo.ssh_clone_url
+    elif use_https:
+        clone_url = repo.https_clone_url
+    else:
+        clone_url = repo.ssh_clone_url or repo.https_clone_url
+
+    if not clone_url:
+        print_error(
+            f"Não foi possível obter uma URL de clone válida para o repositório '{slug}'.",
+            as_json=as_json,
+            code=1,
+        )
+        raise typer.Exit(code=1)
+
+    prov_title = "GitHub" if prov_name == "github" else "Bitbucket"
+    if as_json:
+        print_json(
+            {
+                "status": "cloning",
+                "provider": prov_name,
+                "repo": repo.slug,
+                "clone_url": clone_url,
+            }
+        )
+    else:
+        print_success(
+            f"Iniciando clone de [bold]{repo.name}[/bold] ({prov_title}) via [cyan]{clone_url}[/cyan]..."
+        )
+
+    proc = subprocess.run(["git", "clone", clone_url], check=False)
+    if proc.returncode != 0:
+        print_error(
+            f"Falha ao executar git clone (código {proc.returncode}).",
+            as_json=as_json,
+            code=proc.returncode,
+        )
+        raise typer.Exit(code=proc.returncode)
+
+    print_success(f"Repositório '{repo.slug}' clonado com sucesso!", as_json=as_json)
+
+
+@repo_app.command("create")
+def repo_create(
+    ctx: typer.Context,
+    name: str = Argument(..., help="Nome do repositório a ser criado."),
+    workspace: str | None = Option(
+        None, "--workspace", "-w", help="Workspace ou organização/usuário de destino."
+    ),
+    provider: str | None = Option(
+        None, "--provider", "-p", help="Provedor Git: 'bitbucket' ou 'github'."
+    ),
+    is_private: bool = Option(
+        True, "--private/--public", help="Define se o repositório é privado ou público."
+    ),
+    description: str | None = Option(None, "--description", "-d", help="Descrição do repositório."),
+    yes: bool = Option(False, "--yes", "-y", help="Pula confirmação interativa."),
+) -> None:
+    """Cria um novo repositório no provedor Git (Bitbucket ou GitHub)."""
+    as_json = getattr(ctx.obj, "json_mode", False) if ctx.obj else False
+    prov_name, client = resolve_git_provider(provider, as_json=as_json)
+
+    prov_title = "GitHub" if prov_name == "github" else "Bitbucket"
+    if not yes and not as_json:
+        confirmed = typer.confirm(f"Deseja criar o repositório '{name}' no {prov_title}?")
+        if not confirmed:
+            print_error("Operação cancelada pelo usuário.", as_json=as_json, code=1)
+            raise typer.Exit(code=1)
+
+    try:
+        repo = client.create_repository(
+            name=name,
+            workspace=workspace,
+            is_private=is_private,
+            description=description,
+        )
+        print_success(
+            f"Repositório '{repo.name}' criado com sucesso no {prov_title} ({repo.workspace})!",
+            as_json=as_json,
+            json_payload=repo.model_dump(),
+        )
+    except BitbucketError as e:
+        print_error(f"Falha ao criar repositório: {e}", as_json=as_json, code=1)
+        raise typer.Exit(code=1) from e