vectorgov-cli 0.1.0__py3-none-any.whl

vectorgov/cli/__init__.py

@@ -0,0 +1,12 @@
+"""
+VectorGov CLI - Cliente de linha de comando para a API VectorGov.
+
+Uso:
+    vectorgov search "O que é ETP?"
+    vectorgov ask "Quando o ETP pode ser dispensado?"
+    vectorgov auth login
+"""
+
+from .main import app
+
+__all__ = ["app"]

vectorgov/cli/commands/__init__.py

@@ -0,0 +1,7 @@
+"""
+Comandos do CLI VectorGov.
+"""
+
+from . import auth, search, ask, feedback, docs, config
+
+__all__ = ["auth", "search", "ask", "feedback", "docs", "config"]

vectorgov/cli/commands/ask.py

@@ -0,0 +1,158 @@
+"""
+Comando de perguntas do CLI VectorGov.
+
+Este comando busca contexto relevante e prepara para uso com LLMs.
+O usuário deve usar seu próprio LLM (OpenAI, Anthropic, Google, etc).
+"""
+
+import json
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+from ..utils.config import ConfigManager
+from ..utils.output import OutputFormat
+
+app = typer.Typer()
+console = Console()
+config_manager = ConfigManager()
+
+
+@app.callback(invoke_without_command=True)
+def ask(
+    query: str = typer.Argument(..., help="Pergunta em linguagem natural"),
+    top_k: int = typer.Option(5, "--top-k", "-k", help="Número de chunks para contexto"),
+    mode: str = typer.Option(
+        "balanced",
+        "--mode", "-m",
+        help="Modo de busca: fast, balanced, precise"
+    ),
+    output: OutputFormat = typer.Option(
+        OutputFormat.text,
+        "--output", "-o",
+        help="Formato de saída: text, json, messages"
+    ),
+    raw: bool = typer.Option(False, "--raw", help="Saída sem formatação (JSON bruto)"),
+    show_code: bool = typer.Option(False, "--code", help="Mostrar código de exemplo para LLM"),
+):
+    """
+    Busca contexto relevante para responder uma pergunta.
+
+    O VectorGov retorna os chunks mais relevantes da legislação.
+    Use os métodos to_messages() ou to_context() para integrar com seu LLM.
+
+    Exemplos:
+        vectorgov ask "O que é ETP?"
+        vectorgov ask "Quando o ETP pode ser dispensado?" --mode precise
+        vectorgov ask "critérios de julgamento" --output messages
+        vectorgov ask "O que é ETP?" --code  # Mostra código de exemplo
+    """
+    # Obtém API key
+    api_key = config_manager.get("api_key")
+    if not api_key:
+        console.print("[red]Erro:[/red] API key não configurada.")
+        console.print("  Use 'vectorgov auth login' para configurar.")
+        raise typer.Exit(1)
+
+    # Valida parâmetros
+    if top_k < 1 or top_k > 20:
+        console.print("[red]Erro:[/red] top_k deve estar entre 1 e 20.")
+        raise typer.Exit(1)
+
+    if mode not in ["fast", "balanced", "precise"]:
+        console.print("[red]Erro:[/red] mode deve ser: fast, balanced ou precise.")
+        raise typer.Exit(1)
+
+    # Executa busca
+    try:
+        from vectorgov import VectorGov
+
+        if not raw:
+            console.print(f"Buscando contexto para: [cyan]{query}[/cyan]", style="dim")
+
+        vg = VectorGov(api_key=api_key)
+        results = vg.search(query, top_k=top_k, mode=mode)
+
+        # Formata saída
+        if raw:
+            # JSON bruto para pipes
+            messages = results.to_messages(query)
+            data = {
+                "query": query,
+                "total": results.total,
+                "cached": results.cached,
+                "latency_ms": results.latency_ms,
+                "query_id": results.query_id,
+                "messages": messages,
+                "context": results.to_context(),
+            }
+            print(json.dumps(data, ensure_ascii=False, indent=2))
+
+        elif output == OutputFormat.json or str(output) == "messages":
+            # Formato messages para usar com LLMs
+            messages = results.to_messages(query)
+            data = {
+                "messages": messages,
+                "metadata": {
+                    "query": query,
+                    "total": results.total,
+                    "query_id": results.query_id,
+                }
+            }
+            console.print_json(json.dumps(data, ensure_ascii=False))
+
+        else:  # text
+            # Mostra contexto formatado
+            console.print()
+
+            # Info da busca
+            cache_str = "[green]✓ Cache[/green]" if results.cached else "[dim]Sem cache[/dim]"
+            console.print(f"Encontrados: [cyan]{results.total}[/cyan] chunks | "
+                         f"Latência: [cyan]{results.latency_ms}ms[/cyan] | {cache_str}")
+            console.print()
+
+            # Mostra cada hit
+            for i, hit in enumerate(results.hits, 1):
+                title = f"[bold]#{i}[/bold] Art. {hit.article_number} ({hit.document_id})"
+                console.print(Panel(
+                    hit.text[:500] + ("..." if len(hit.text) > 500 else ""),
+                    title=title,
+                    border_style="blue"
+                ))
+                console.print()
+
+            # Query ID para feedback
+            console.print(f"[dim]Query ID: {results.query_id}[/dim]")
+            console.print("[dim]Use 'vectorgov feedback <query_id> --like' para avaliar[/dim]")
+
+            # Mostra código de exemplo se solicitado
+            if show_code:
+                console.print()
+                console.print("[bold yellow]Código de exemplo para usar com LLM:[/bold yellow]")
+                code = f'''from vectorgov import VectorGov
+from openai import OpenAI  # ou anthropic, google-generativeai, etc.
+
+vg = VectorGov(api_key="vg_xxx")
+openai = OpenAI()
+
+results = vg.search("{query}", top_k={top_k})
+
+# Usar com OpenAI
+response = openai.chat.completions.create(
+    model="gpt-4o",
+    messages=results.to_messages("{query}")
+)
+print(response.choices[0].message.content)
+
+# Ou usar contexto diretamente
+context = results.to_context()
+'''
+                console.print(Syntax(code, "python", theme="monokai"))
+
+    except Exception as e:
+        console.print(f"[red]Erro:[/red] {e}")
+        raise typer.Exit(1)

vectorgov/cli/commands/auth.py

@@ -0,0 +1,106 @@
+"""
+Comandos de autenticação do CLI VectorGov.
+"""
+
+import typer
+from rich.console import Console
+from rich.prompt import Prompt
+
+from ..utils.config import ConfigManager
+
+app = typer.Typer(no_args_is_help=True)
+console = Console()
+config_manager = ConfigManager()
+
+
+@app.command()
+def login(
+    api_key: str = typer.Option(
+        None,
+        "--api-key", "-k",
+        help="API key do VectorGov. Se não fornecida, será solicitada interativamente."
+    ),
+):
+    """
+    Configura a API key para autenticação.
+
+    Exemplo:
+        vectorgov auth login
+        vectorgov auth login --api-key vg_sua_chave
+    """
+    if not api_key:
+        api_key = Prompt.ask("Digite sua API key", password=True)
+
+    if not api_key.startswith("vg_"):
+        console.print("[red]Erro:[/red] API key deve começar com 'vg_'")
+        raise typer.Exit(1)
+
+    # Testa a API key
+    console.print("Validando API key...", style="dim")
+    try:
+        from vectorgov import VectorGov
+        vg = VectorGov(api_key=api_key)
+        # Faz uma busca simples para validar
+        vg.search("teste", top_k=1)
+        console.print("[green]✓[/green] API key válida!")
+    except Exception as e:
+        console.print(f"[red]✗[/red] Erro ao validar API key: {e}")
+        raise typer.Exit(1)
+
+    # Salva a configuração
+    config_manager.set("api_key", api_key)
+    console.print("[green]✓[/green] Configuração salva com sucesso!")
+    console.print(f"  Arquivo: {config_manager.config_file}")
+
+
+@app.command()
+def logout():
+    """
+    Remove a API key salva.
+
+    Exemplo:
+        vectorgov auth logout
+    """
+    if config_manager.get("api_key"):
+        config_manager.delete("api_key")
+        console.print("[green]✓[/green] API key removida com sucesso!")
+    else:
+        console.print("[yellow]![/yellow] Nenhuma API key configurada.")
+
+
+@app.command()
+def status():
+    """
+    Mostra o status da autenticação atual.
+
+    Exemplo:
+        vectorgov auth status
+    """
+    api_key = config_manager.get("api_key")
+
+    if not api_key:
+        console.print("[yellow]![/yellow] Nenhuma API key configurada.")
+        console.print("  Use 'vectorgov auth login' para configurar.")
+        return
+
+    # Mascara a API key
+    masked = api_key[:8] + "..." + api_key[-4:]
+    console.print(f"[green]✓[/green] API key configurada: {masked}")
+
+    # Testa a conexão
+    console.print("Testando conexão...", style="dim")
+    try:
+        from vectorgov import VectorGov
+        vg = VectorGov(api_key=api_key)
+        vg.search("teste", top_k=1)
+        console.print("[green]✓[/green] Conexão OK!")
+    except Exception as e:
+        console.print(f"[red]✗[/red] Erro na conexão: {e}")
+
+
+@app.command()
+def whoami():
+    """
+    Alias para 'status'. Mostra informações da conta atual.
+    """
+    status()

vectorgov/cli/commands/config.py

@@ -0,0 +1,114 @@
+"""
+Comando de configuração do CLI VectorGov.
+"""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..utils.config import ConfigManager
+
+app = typer.Typer(no_args_is_help=True)
+console = Console()
+config_manager = ConfigManager()
+
+
+@app.command("set")
+def config_set(
+    key: str = typer.Argument(..., help="Nome da configuração"),
+    value: str = typer.Argument(..., help="Valor da configuração"),
+):
+    """
+    Define uma configuração.
+
+    Exemplos:
+        vectorgov config set api_key vg_sua_chave
+        vectorgov config set default_mode precise
+    """
+    # Valida chaves conhecidas
+    valid_keys = ["api_key", "default_mode", "default_top_k", "output_format"]
+
+    if key not in valid_keys:
+        console.print(f"[yellow]Aviso:[/yellow] '{key}' não é uma chave conhecida.")
+        console.print(f"Chaves válidas: {', '.join(valid_keys)}")
+
+    config_manager.set(key, value)
+    console.print(f"[green]✓[/green] Configuração '{key}' salva!")
+
+
+@app.command("get")
+def config_get(
+    key: str = typer.Argument(..., help="Nome da configuração"),
+):
+    """
+    Obtém uma configuração.
+
+    Exemplos:
+        vectorgov config get api_key
+        vectorgov config get default_mode
+    """
+    value = config_manager.get(key)
+
+    if value is None:
+        console.print(f"[yellow]![/yellow] Configuração '{key}' não definida.")
+    else:
+        # Mascara API key
+        if key == "api_key" and value:
+            value = value[:8] + "..." + value[-4:]
+        console.print(f"{key}: {value}")
+
+
+@app.command("list")
+def config_list():
+    """
+    Lista todas as configurações.
+
+    Exemplo:
+        vectorgov config list
+    """
+    configs = config_manager.list_all()
+
+    if not configs:
+        console.print("[yellow]![/yellow] Nenhuma configuração definida.")
+        return
+
+    table = Table(title="Configurações")
+    table.add_column("Chave", style="cyan")
+    table.add_column("Valor")
+
+    for key, value in configs.items():
+        # Mascara API key
+        if key == "api_key" and value:
+            value = value[:8] + "..." + value[-4:]
+        table.add_row(key, str(value))
+
+    console.print(table)
+    console.print(f"\nArquivo: {config_manager.config_file}")
+
+
+@app.command("delete")
+def config_delete(
+    key: str = typer.Argument(..., help="Nome da configuração"),
+):
+    """
+    Remove uma configuração.
+
+    Exemplo:
+        vectorgov config delete default_mode
+    """
+    if config_manager.get(key):
+        config_manager.delete(key)
+        console.print(f"[green]✓[/green] Configuração '{key}' removida!")
+    else:
+        console.print(f"[yellow]![/yellow] Configuração '{key}' não existe.")
+
+
+@app.command("path")
+def config_path():
+    """
+    Mostra o caminho do arquivo de configuração.
+
+    Exemplo:
+        vectorgov config path
+    """
+    console.print(f"Arquivo de configuração: {config_manager.config_file}")

vectorgov/cli/commands/docs.py

@@ -0,0 +1,113 @@
+"""
+Comando de documentos do CLI VectorGov.
+"""
+
+import json
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..utils.config import ConfigManager
+
+app = typer.Typer(no_args_is_help=True)
+console = Console()
+config_manager = ConfigManager()
+
+
+@app.command("list")
+def list_docs(
+    output: str = typer.Option("table", "--output", "-o", help="Formato: table, json"),
+):
+    """
+    Lista documentos disponíveis na base.
+
+    Exemplos:
+        vectorgov docs list
+        vectorgov docs list --output json
+    """
+    # Obtém API key
+    api_key = config_manager.get("api_key")
+    if not api_key:
+        console.print("[red]Erro:[/red] API key não configurada.")
+        console.print("  Use 'vectorgov auth login' para configurar.")
+        raise typer.Exit(1)
+
+    try:
+        from vectorgov import VectorGov
+
+        vg = VectorGov(api_key=api_key)
+        docs = vg.list_documents()
+
+        if output == "json":
+            data = [
+                {
+                    "id": d.id,
+                    "title": d.title,
+                    "type": d.type,
+                    "year": d.year,
+                    "chunks": d.chunks_count,
+                }
+                for d in docs
+            ]
+            console.print_json(json.dumps(data, ensure_ascii=False))
+        else:
+            table = Table(title="Documentos Disponíveis")
+            table.add_column("ID", style="cyan")
+            table.add_column("Título")
+            table.add_column("Tipo", style="green")
+            table.add_column("Ano", justify="right")
+            table.add_column("Chunks", justify="right")
+
+            for d in docs:
+                table.add_row(
+                    d.id,
+                    d.title[:50] + "..." if len(d.title) > 50 else d.title,
+                    d.type,
+                    str(d.year),
+                    str(d.chunks_count),
+                )
+
+            console.print(table)
+            console.print(f"\nTotal: {len(docs)} documentos")
+
+    except Exception as e:
+        console.print(f"[red]Erro:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("info")
+def doc_info(
+    document_id: str = typer.Argument(..., help="ID do documento"),
+):
+    """
+    Mostra informações detalhadas de um documento.
+
+    Exemplos:
+        vectorgov docs info LEI-14133-2021
+        vectorgov docs info IN-58-2022
+    """
+    # Obtém API key
+    api_key = config_manager.get("api_key")
+    if not api_key:
+        console.print("[red]Erro:[/red] API key não configurada.")
+        console.print("  Use 'vectorgov auth login' para configurar.")
+        raise typer.Exit(1)
+
+    try:
+        from vectorgov import VectorGov
+
+        vg = VectorGov(api_key=api_key)
+        doc = vg.get_document(document_id)
+
+        console.print(f"\n[bold]{doc.title}[/bold]")
+        console.print(f"ID: [cyan]{doc.id}[/cyan]")
+        console.print(f"Tipo: [green]{doc.type}[/green]")
+        console.print(f"Ano: {doc.year}")
+        console.print(f"Chunks: {doc.chunks_count}")
+
+        if hasattr(doc, 'description') and doc.description:
+            console.print(f"\nDescrição: {doc.description}")
+
+    except Exception as e:
+        console.print(f"[red]Erro:[/red] {e}")
+        raise typer.Exit(1)

vectorgov/cli/commands/feedback.py

@@ -0,0 +1,59 @@
+"""
+Comando de feedback do CLI VectorGov.
+"""
+
+import typer
+from rich.console import Console
+
+from ..utils.config import ConfigManager
+
+app = typer.Typer()
+console = Console()
+config_manager = ConfigManager()
+
+
+@app.callback(invoke_without_command=True)
+def feedback(
+    query_id: str = typer.Argument(..., help="ID da query (obtido após search ou ask)"),
+    like: bool = typer.Option(None, "--like", "-l", help="Marcar como positivo"),
+    dislike: bool = typer.Option(None, "--dislike", "-d", help="Marcar como negativo"),
+):
+    """
+    Envia feedback sobre uma resposta (like/dislike).
+
+    Exemplos:
+        vectorgov feedback abc123 --like
+        vectorgov feedback abc123 --dislike
+    """
+    # Valida opções
+    if like is None and dislike is None:
+        console.print("[red]Erro:[/red] Especifique --like ou --dislike")
+        raise typer.Exit(1)
+
+    if like and dislike:
+        console.print("[red]Erro:[/red] Use apenas --like OU --dislike, não ambos")
+        raise typer.Exit(1)
+
+    is_like = like if like is not None else not dislike
+
+    # Obtém API key
+    api_key = config_manager.get("api_key")
+    if not api_key:
+        console.print("[red]Erro:[/red] API key não configurada.")
+        console.print("  Use 'vectorgov auth login' para configurar.")
+        raise typer.Exit(1)
+
+    # Envia feedback
+    try:
+        from vectorgov import VectorGov
+
+        vg = VectorGov(api_key=api_key)
+        vg.feedback(query_id, like=is_like)
+
+        emoji = "👍" if is_like else "👎"
+        status = "positivo" if is_like else "negativo"
+        console.print(f"[green]✓[/green] Feedback {emoji} {status} enviado com sucesso!")
+
+    except Exception as e:
+        console.print(f"[red]Erro:[/red] {e}")
+        raise typer.Exit(1)

vectorgov/cli/commands/search.py

@@ -0,0 +1,97 @@
+"""
+Comando de busca do CLI VectorGov.
+"""
+
+import json
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from ..utils.config import ConfigManager
+from ..utils.output import OutputFormat, format_search_results
+
+app = typer.Typer()
+console = Console()
+config_manager = ConfigManager()
+
+
+@app.callback(invoke_without_command=True)
+def search(
+    query: str = typer.Argument(..., help="Pergunta ou termo de busca"),
+    top_k: int = typer.Option(5, "--top-k", "-k", help="Número de resultados (1-20)"),
+    mode: str = typer.Option(
+        "balanced",
+        "--mode", "-m",
+        help="Modo de busca: fast, balanced, precise"
+    ),
+    use_cache: bool = typer.Option(False, "--cache", help="Usar cache semântico"),
+    output: OutputFormat = typer.Option(
+        OutputFormat.table,
+        "--output", "-o",
+        help="Formato de saída: table, json, text"
+    ),
+    raw: bool = typer.Option(False, "--raw", help="Saída sem formatação (JSON bruto)"),
+):
+    """
+    Busca documentos na base de legislação.
+
+    Exemplos:
+        vectorgov search "O que é ETP?"
+        vectorgov search "pesquisa de preços" --top-k 10
+        vectorgov search "licitação" --mode precise --output json
+    """
+    # Obtém API key
+    api_key = config_manager.get("api_key")
+    if not api_key:
+        console.print("[red]Erro:[/red] API key não configurada.")
+        console.print("  Use 'vectorgov auth login' para configurar.")
+        raise typer.Exit(1)
+
+    # Valida parâmetros
+    if top_k < 1 or top_k > 20:
+        console.print("[red]Erro:[/red] top_k deve estar entre 1 e 20.")
+        raise typer.Exit(1)
+
+    if mode not in ["fast", "balanced", "precise"]:
+        console.print("[red]Erro:[/red] mode deve ser: fast, balanced ou precise.")
+        raise typer.Exit(1)
+
+    # Executa busca
+    try:
+        from vectorgov import VectorGov
+
+        if not raw:
+            console.print(f"Buscando: [cyan]{query}[/cyan]", style="dim")
+
+        vg = VectorGov(api_key=api_key)
+        results = vg.search(query, top_k=top_k, mode=mode, use_cache=use_cache)
+
+        # Formata saída
+        if raw:
+            # JSON bruto para pipes
+            data = {
+                "query": query,
+                "total": results.total,
+                "cached": results.cached,
+                "latency_ms": results.latency_ms,
+                "query_id": results.query_id,
+                "hits": [
+                    {
+                        "text": h.text,
+                        "article_number": h.article_number,
+                        "document_id": h.document_id,
+                        "score": h.score,
+                    }
+                    for h in results.hits
+                ]
+            }
+            print(json.dumps(data, ensure_ascii=False, indent=2))
+        else:
+            format_search_results(console, results, output, query)
+
+    except Exception as e:
+        console.print(f"[red]Erro:[/red] {e}")
+        raise typer.Exit(1)

vectorgov/cli/main.py

@@ -0,0 +1,53 @@
+"""
+Ponto de entrada principal do CLI VectorGov.
+"""
+
+import typer
+from rich.console import Console
+
+from .commands import auth, search, ask, feedback, docs, config
+
+# Console para output formatado
+console = Console()
+
+# App principal
+app = typer.Typer(
+    name="vectorgov",
+    help="CLI para a API VectorGov - Busca semântica em legislação brasileira",
+    add_completion=True,
+    no_args_is_help=True,
+)
+
+# Registra subcomandos
+app.add_typer(auth.app, name="auth", help="Autenticação e gerenciamento de credenciais")
+app.add_typer(search.app, name="search", help="Buscar documentos na base de legislação")
+app.add_typer(ask.app, name="ask", help="Fazer perguntas com resposta de IA")
+app.add_typer(feedback.app, name="feedback", help="Enviar feedback sobre respostas")
+app.add_typer(docs.app, name="docs", help="Listar e consultar documentos disponíveis")
+app.add_typer(config.app, name="config", help="Gerenciar configurações")
+
+
+@app.command()
+def version():
+    """Mostra a versão do CLI."""
+    from vectorgov import __version__
+    console.print(f"vectorgov-cli versão {__version__}")
+
+
+@app.callback()
+def callback():
+    """
+    VectorGov CLI - Busca semântica em legislação brasileira.
+
+    Use 'vectorgov COMANDO --help' para mais informações sobre cada comando.
+    """
+    pass
+
+
+def main():
+    """Função principal executada pelo entry point."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

vectorgov/cli/utils/__init__.py

@@ -0,0 +1,8 @@
+"""
+Utilitários do CLI VectorGov.
+"""
+
+from .config import ConfigManager
+from .output import OutputFormat, format_search_results
+
+__all__ = ["ConfigManager", "OutputFormat", "format_search_results"]

vectorgov/cli/utils/config.py

@@ -0,0 +1,110 @@
+"""
+Gerenciador de configuração do CLI VectorGov.
+
+Armazena configurações em ~/.vectorgov/config.yaml
+"""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+
+class ConfigManager:
+    """Gerencia configurações do CLI em arquivo YAML."""
+
+    def __init__(self):
+        """Inicializa o gerenciador de configuração."""
+        self.config_dir = Path.home() / ".vectorgov"
+        self.config_file = self.config_dir / "config.yaml"
+        self._config: Optional[Dict[str, Any]] = None
+
+    def _ensure_dir(self):
+        """Garante que o diretório de configuração existe."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    def _load(self) -> Dict[str, Any]:
+        """Carrega configuração do arquivo."""
+        if self._config is not None:
+            return self._config
+
+        if self.config_file.exists():
+            with open(self.config_file, "r", encoding="utf-8") as f:
+                self._config = yaml.safe_load(f) or {}
+        else:
+            self._config = {}
+
+        return self._config
+
+    def _save(self):
+        """Salva configuração no arquivo."""
+        self._ensure_dir()
+        with open(self.config_file, "w", encoding="utf-8") as f:
+            yaml.dump(self._config, f, default_flow_style=False, allow_unicode=True)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Obtém valor de uma configuração.
+
+        Prioridade:
+        1. Variável de ambiente (VECTORGOV_<KEY>)
+        2. Arquivo de configuração
+        3. Valor padrão
+
+        Args:
+            key: Nome da configuração
+            default: Valor padrão se não encontrado
+
+        Returns:
+            Valor da configuração
+        """
+        # Tenta variável de ambiente primeiro
+        env_key = f"VECTORGOV_{key.upper()}"
+        env_value = os.environ.get(env_key)
+        if env_value is not None:
+            return env_value
+
+        # Tenta arquivo de configuração
+        config = self._load()
+        return config.get(key, default)
+
+    def set(self, key: str, value: Any):
+        """
+        Define valor de uma configuração.
+
+        Args:
+            key: Nome da configuração
+            value: Valor a ser salvo
+        """
+        config = self._load()
+        config[key] = value
+        self._config = config
+        self._save()
+
+    def delete(self, key: str):
+        """
+        Remove uma configuração.
+
+        Args:
+            key: Nome da configuração
+        """
+        config = self._load()
+        if key in config:
+            del config[key]
+            self._config = config
+            self._save()
+
+    def list_all(self) -> Dict[str, Any]:
+        """
+        Lista todas as configurações.
+
+        Returns:
+            Dicionário com todas as configurações
+        """
+        return self._load().copy()
+
+    def clear(self):
+        """Remove todas as configurações."""
+        self._config = {}
+        self._save()

vectorgov/cli/utils/output.py

@@ -0,0 +1,103 @@
+"""
+Utilitários de formatação de saída do CLI VectorGov.
+"""
+
+import json
+from enum import Enum
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+
+class OutputFormat(str, Enum):
+    """Formatos de saída suportados."""
+    table = "table"
+    json = "json"
+    text = "text"
+    markdown = "markdown"
+
+
+def format_search_results(console: Console, results: Any, output_format: OutputFormat, query: str):
+    """
+    Formata e exibe resultados de busca.
+
+    Args:
+        console: Console Rich para output
+        results: Objeto SearchResult da API
+        output_format: Formato desejado
+        query: Query original
+    """
+    if output_format == OutputFormat.json:
+        data = {
+            "query": query,
+            "total": results.total,
+            "cached": results.cached,
+            "latency_ms": results.latency_ms,
+            "query_id": results.query_id,
+            "hits": [
+                {
+                    "text": h.text,
+                    "article_number": getattr(h, "article_number", None),
+                    "document_id": getattr(h, "document_id", None),
+                    "score": h.score,
+                }
+                for h in results.hits
+            ]
+        }
+        console.print_json(json.dumps(data, ensure_ascii=False))
+
+    elif output_format == OutputFormat.table:
+        # Cabeçalho
+        console.print()
+        console.print(f"[bold]Resultados para:[/bold] {query}")
+        console.print(f"[dim]Total: {results.total} | Latência: {results.latency_ms:.0f}ms | Cache: {'Sim' if results.cached else 'Não'}[/dim]")
+        console.print()
+
+        # Tabela
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("#", justify="right", style="dim", width=3)
+        table.add_column("Artigo", style="green", width=10)
+        table.add_column("Texto", width=60)
+        table.add_column("Score", justify="right", width=8)
+
+        for i, hit in enumerate(results.hits, 1):
+            article = getattr(hit, "article_number", "-") or "-"
+            text = hit.text[:100] + "..." if len(hit.text) > 100 else hit.text
+            text = text.replace("\n", " ")
+            table.add_row(str(i), str(article), text, f"{hit.score:.3f}")
+
+        console.print(table)
+
+        # Footer
+        console.print(f"\n[dim]Query ID: {results.query_id}[/dim]")
+        console.print("[dim]Use 'vectorgov feedback <query_id> --like' para avaliar[/dim]")
+
+    else:  # text
+        console.print()
+        console.print(Panel(f"[bold]{query}[/bold]", title="Busca", border_style="blue"))
+
+        for i, hit in enumerate(results.hits, 1):
+            article = getattr(hit, "article_number", None)
+            header = f"[{i}] Art. {article}" if article else f"[{i}]"
+
+            console.print(f"\n[bold cyan]{header}[/bold cyan] (score: {hit.score:.3f})")
+            console.print(hit.text[:300] + "..." if len(hit.text) > 300 else hit.text)
+
+        console.print(f"\n[dim]Total: {results.total} | Latência: {results.latency_ms:.0f}ms[/dim]")
+        console.print(f"[dim]Query ID: {results.query_id}[/dim]")
+
+
+def format_code_block(console: Console, code: str, language: str = "python"):
+    """
+    Formata e exibe um bloco de código.
+
+    Args:
+        console: Console Rich
+        code: Código a exibir
+        language: Linguagem para syntax highlighting
+    """
+    from rich.syntax import Syntax
+    syntax = Syntax(code, language, theme="monokai", line_numbers=True)
+    console.print(syntax)

vectorgov_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,273 @@
+Metadata-Version: 2.4
+Name: vectorgov-cli
+Version: 0.1.0
+Summary: CLI para a API VectorGov - Busca semântica em legislação brasileira
+Project-URL: Homepage, https://vectorgov.io
+Project-URL: Documentation, https://vectorgov.io/documentacao
+Project-URL: Repository, https://github.com/euteajudo/vectorgov-cli
+Project-URL: Issues, https://github.com/euteajudo/vectorgov-cli/issues
+Author-email: VectorGov <contato@vectorgov.io>
+License-Expression: MIT
+Keywords: brazil,cli,legal,legislation,licitacao,rag,semantic-search,vectorgov
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.9
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: vectorgov>=0.13.0
+Provides-Extra: all
+Requires-Dist: anthropic>=0.18.0; extra == 'all'
+Requires-Dist: google-generativeai>=0.3.0; extra == 'all'
+Requires-Dist: langchain-core>=0.1.0; extra == 'all'
+Requires-Dist: langchain>=0.1.0; extra == 'all'
+Requires-Dist: openai>=1.0.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.18.0; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: isort>=5.12.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: google
+Requires-Dist: google-generativeai>=0.3.0; extra == 'google'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.1.0; extra == 'langchain'
+Requires-Dist: langchain>=0.1.0; extra == 'langchain'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# VectorGov CLI
+
+Cliente de linha de comando para a API VectorGov - Busca semântica em legislação brasileira.
+
+[![PyPI version](https://badge.fury.io/py/vectorgov-cli.svg)](https://badge.fury.io/py/vectorgov-cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Instalação
+
+```bash
+pip install vectorgov-cli
+```
+
+## Configuração
+
+```bash
+# Configure sua API key
+vectorgov auth login
+
+# Ou via variável de ambiente
+export VECTORGOV_API_KEY="vg_sua_chave"
+```
+
+## Uso
+
+### Busca
+
+```bash
+# Busca simples
+vectorgov search "O que é ETP?"
+
+# Com opções
+vectorgov search "pesquisa de preços" --top-k 10 --mode precise
+
+# Saída em JSON
+vectorgov search "licitação" --output json
+
+# JSON bruto (para pipes)
+vectorgov search "licitação" --raw | jq '.hits[0].text'
+```
+
+### Perguntas (contexto para LLM)
+
+O comando `ask` busca contexto relevante para você usar com seu próprio LLM (OpenAI, Anthropic, Google, etc).
+
+```bash
+# Busca contexto para pergunta
+vectorgov ask "O que é ETP?"
+
+# Com mais contexto
+vectorgov ask "Quando o ETP pode ser dispensado?" --top-k 10 --mode precise
+
+# Saída em formato messages (pronto para LLM)
+vectorgov ask "critérios de julgamento" --output json
+
+# Mostrar código de exemplo para integração
+vectorgov ask "O que é ETP?" --code
+```
+
+**Exemplo de integração com OpenAI:**
+
+```python
+from vectorgov import VectorGov
+from openai import OpenAI
+
+vg = VectorGov(api_key="vg_xxx")
+openai = OpenAI()
+
+results = vg.search("O que é ETP?", top_k=5)
+
+response = openai.chat.completions.create(
+    model="gpt-4o",
+    messages=results.to_messages("O que é ETP?")
+)
+print(response.choices[0].message.content)
+```
+
+### Feedback
+
+```bash
+# Após uma busca, use o query_id para feedback
+vectorgov feedback abc123def456 --like
+vectorgov feedback abc123def456 --dislike
+```
+
+### Documentos
+
+```bash
+# Lista documentos disponíveis
+vectorgov docs list
+
+# Informações de um documento
+vectorgov docs info LEI-14133-2021
+```
+
+### Configuração
+
+```bash
+# Ver configuração atual
+vectorgov config list
+
+# Definir configuração
+vectorgov config set default_mode precise
+vectorgov config set default_top_k 10
+
+# Ver valor específico
+vectorgov config get api_key
+
+# Remover configuração
+vectorgov config delete default_mode
+```
+
+### Autenticação
+
+```bash
+# Login (salva API key)
+vectorgov auth login
+
+# Status da autenticação
+vectorgov auth status
+
+# Logout (remove API key)
+vectorgov auth logout
+```
+
+## Formatos de Saída
+
+### Tabela (padrão para search)
+
+```bash
+vectorgov search "O que é ETP?" --output table
+```
+
+```
+Resultados para: O que é ETP?
+Total: 5 | Latência: 1234ms | Cache: Não
+
+┏━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┓
+┃ # ┃ Artigo    ┃ Texto                                                          ┃ Score   ┃
+┡━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━┩
+│ 1 │ Art. 3    │ ETP - Estudo Técnico Preliminar: documento constitutivo...     │ 0.892   │
+│ 2 │ Art. 1    │ Esta Instrução Normativa dispõe sobre a elaboração...          │ 0.856   │
+└───┴───────────┴────────────────────────────────────────────────────────────────┴─────────┘
+```
+
+### JSON
+
+```bash
+vectorgov search "O que é ETP?" --output json
+```
+
+```json
+{
+  "query": "O que é ETP?",
+  "total": 5,
+  "cached": false,
+  "latency_ms": 1234,
+  "hits": [
+    {
+      "text": "ETP - Estudo Técnico Preliminar...",
+      "article_number": "3",
+      "score": 0.892
+    }
+  ]
+}
+```
+
+## Integração com Outros Comandos
+
+```bash
+# Buscar e processar com jq
+vectorgov search "ETP" --raw | jq '.hits[0].text'
+
+# Buscar e salvar
+vectorgov search "licitação" --output json > resultados.json
+
+# Usar em scripts
+QUERY_ID=$(vectorgov search "ETP" --raw | jq -r '.query_id')
+vectorgov feedback $QUERY_ID --like
+
+# Obter contexto para LLM
+vectorgov ask "O que é ETP?" --raw | jq '.messages'
+```
+
+## Variáveis de Ambiente
+
+| Variável | Descrição |
+|----------|-----------|
+| `VECTORGOV_API_KEY` | API key para autenticação |
+| `VECTORGOV_DEFAULT_MODE` | Modo de busca padrão (fast, balanced, precise) |
+| `VECTORGOV_DEFAULT_TOP_K` | Número padrão de resultados |
+
+## Arquivo de Configuração
+
+Localização: `~/.vectorgov/config.yaml`
+
+```yaml
+api_key: vg_sua_chave
+default_mode: balanced
+default_top_k: 5
+output_format: table
+```
+
+## Ajuda
+
+```bash
+# Ajuda geral
+vectorgov --help
+
+# Ajuda de comando específico
+vectorgov search --help
+vectorgov ask --help
+```
+
+## Links
+
+- [Documentação](https://vectorgov.io/documentacao)
+- [Playground](https://vectorgov.io/playground)
+- [SDK Python](https://pypi.org/project/vectorgov/)
+- [SDK TypeScript](https://www.npmjs.com/package/vectorgov)

vectorgov_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+vectorgov/cli/__init__.py,sha256=dgdWdxMKLu2ysK2cicVF1oB38j52q90oh4xuLZKQHz8,250
+vectorgov/cli/main.py,sha256=5hVUoLm4DTwnxSXZBEYt_k3wo7GEa8-dwFLdyiBDgN8,1485
+vectorgov/cli/commands/__init__.py,sha256=1t9iUOTIBF_3_y4k1KmhPSWGgB9v7GtKohxV8wzxIlU,166
+vectorgov/cli/commands/ask.py,sha256=c2eQdQzJhk85Xq74gFf0vhiC1lAyGf2o2K7xeXCWIrE,5630
+vectorgov/cli/commands/auth.py,sha256=MZYeo1_R6JqIXvHvM2rOiwGlpNpuF79kOFdYAYf1Y4E,2933
+vectorgov/cli/commands/config.py,sha256=6J5bihAIrBi1kfaVnFxN9Y8uD55osHuzfCZxNdz3XWg,3057
+vectorgov/cli/commands/docs.py,sha256=eRMmv7m2SYzV3szq1WTj7pDDJ_x8dpHzpFFuGcxJ97U,3373
+vectorgov/cli/commands/feedback.py,sha256=RInF4K5hXY_580qSwwmT7o3MZS_TG05lAndwa6NEjeI,1827
+vectorgov/cli/commands/search.py,sha256=gf_QmciLBQmzOy_8ZO0QO854ydNoTKmu5vyWfVPzoC8,3155
+vectorgov/cli/utils/__init__.py,sha256=QhieGpT2tysFWQc6647tsctJ4O2WAJMPrwHFcLQE0HI,208
+vectorgov/cli/utils/config.py,sha256=R_WPLTKidn1pXftKWWpAB3ikCJeayEoWqkX6i8K6NxI,3096
+vectorgov/cli/utils/output.py,sha256=fTvvol_HAFLIm_SX8bEEoL0eV8ZSAAvt8fd1q3vYGGE,3669
+vectorgov_cli-0.1.0.dist-info/METADATA,sha256=MsAU7KTuN1n6uTu0ETXLFQjWTuNTpJGk331pNqWJL54,7662
+vectorgov_cli-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+vectorgov_cli-0.1.0.dist-info/entry_points.txt,sha256=F-9wuWEqDFIrwi2B5_JkGDvUM1jjwzQod598JUs59YE,54
+vectorgov_cli-0.1.0.dist-info/RECORD,,

vectorgov_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

vectorgov_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vectorgov = vectorgov.cli.main:main