feat(ide): mcp servers

docs/AI Coding/COMO_CONFIGURAR_VSCODE_COM_IA.md

@@ -0,0 +1,127 @@
+# Guia: Configurando o VSCode com Modelos de IA (OpenRouter, Ollama e Proxy)
+
+Este guia detalha como configurar o Visual Studio Code para usar diferentes provedores de modelos de linguagem (LLMs) para assistência de codificação, aproveitando a funcionalidade nativa "Bring Your Own Key" (BYOK).
+
+## 1. Configurando com OpenRouter
+
+O OpenRouter oferece acesso a uma vasta gama de modelos de diferentes provedores através de uma única API.
+
+**Passo-a-passo:**
+
+1.  **Obtenha a API Key:**
+    *   Acesse o site do [OpenRouter](https://openrouter.ai/).
+    *   Faça login e navegue até a sua página de "Keys" para criar ou copiar sua chave de API.
+
+2.  **Configure o VSCode:**
+    *   Abra o VSCode e vá para as configurações em JSON (`Ctrl + Shift + P` e procure por `Preferences: Open User Settings (JSON)`).
+    *   Adicione o seguinte bloco de configuração ao seu `settings.json`, substituindo `"MODELS_HERE"` pelos modelos que deseja usar (ex: `"mistralai/mistral-7b-instruct-free"`) e `"YOUR_OPENROUTER_API_KEY"` pela sua chave.
+
+    ```json
+    "github.copilot.languageModels": [
+      {
+        "provider": "openrouter",
+        "model": "MODELS_HERE", // Ex: "mistralai/mistral-7b-instruct-free" ou "google/gemini-flash-1.5"
+        "apiKey": "YOUR_OPENROUTER_API_KEY",
+        "url": "https://openrouter.ai/api/v1"
+      }
+    ]
+    ```
+
+    *   **Nota:** Você pode adicionar vários modelos e alternar entre eles diretamente no VSCode.
+
+## 2. Configurando com Ollama (Local e WSL)
+
+Ollama permite que você execute modelos de linguagem open-source diretamente na sua máquina.
+
+### a. Ollama Local (Linux/macOS)
+
+1.  **Instale o Ollama:** Siga as instruções de instalação no [site oficial do Ollama](https://ollama.com/).
+2.  **Baixe um Modelo:** Abra seu terminal e baixe um modelo de codificação.
+    ```bash
+    ollama pull codellama
+    ```
+3.  **Configure o VSCode:** Adicione a seguinte configuração ao seu `settings.json`. O Ollama, por padrão, roda em `http://localhost:11434`.
+
+    ```json
+    "github.copilot.languageModels": [
+      {
+        "provider": "ollama",
+        "model": "codellama", // Ou qualquer outro modelo que você baixou
+        "url": "http://localhost:11434"
+      }
+    ]
+    ```
+
+### b. Ollama no Windows com WSL (Windows Subsystem for Linux)
+
+A maneira mais fácil e recomendada é rodar o VSCode diretamente de dentro do ambiente WSL.
+
+1.  **Instale o Ollama no WSL:** Abra seu terminal WSL e instale o Ollama seguindo as instruções para Linux.
+2.  **Baixe um Modelo no WSL:**
+    ```bash
+    ollama pull deepseek-coder
+    ```
+3.  **Abra o VSCode no WSL:** No seu terminal WSL, navegue até a pasta do seu projeto e digite `code .`. Isso abrirá o VSCode conectado ao ambiente WSL.
+4.  **Configure o VSCode (mesmo que local):** Como o VSCode está rodando "dentro" do WSL, o `localhost` se refere ao próprio WSL. A configuração no `settings.json` é idêntica à de um ambiente Linux nativo.
+
+    ```json
+    "github.copilot.languageModels": [
+      {
+        "provider": "ollama",
+        "model": "deepseek-coder",
+        "url": "http://localhost:11434"
+      }
+    ]
+    ```
+
+## 3. Rodando com um Proxy (Ex: OpenAI)
+
+Se você está atrás de uma VPN ou firewall que bloqueia o acesso direto a serviços como OpenAI, você pode configurar o VSCode para usar um proxy.
+
+1.  **Configure o Proxy no VSCode:** Adicione a seguinte configuração global ao seu `settings.json`, substituindo pelo endereço e porta do seu proxy.
+
+    ```json
+    "http.proxy": "http://SEU_PROXY_HOST:PORTA"
+    ```
+
+2.  **Configure o Provedor de Modelo:** Agora, configure o provedor do modelo (como OpenAI) normalmente. O VSCode automaticamente roteará a requisição através do proxy configurado.
+
+    ```json
+    "github.copilot.languageModels": [
+      {
+        "provider": "openai",
+        "model": "gpt-4o",
+        "apiKey": "YOUR_OPENAI_API_KEY"
+      }
+    ]
+    ```
+    *   **Importante:** A configuração de `languageModels` não possui um campo de proxy próprio; ela respeita a configuração `http.proxy` global do VSCode.
+
+## 4. Recomendações de Hardware para Ollama
+
+O desempenho do Ollama depende principalmente da **RAM** (para carregar o modelo) e da **VRAM** (memória da GPU, para processamento rápido).
+
+*   **RAM Mínima:**
+    *   **8 GB:** Suficiente para modelos de ~3 bilhões (3B) de parâmetros com quantização (ex: `phi-3`).
+    *   **16 GB:** Recomendado para modelos de 7B (ex: `codellama:7b`, `llama3:8b`). Essa é a configuração mais comum e com melhor custo-benefício.
+    *   **32 GB+:** Necessário para modelos de 13B ou maiores (ex: `codellama:34b`).
+
+*   **GPU (Altamente Recomendado):**
+    *   **NVIDIA:** A melhor opção devido ao suporte CUDA. Uma GPU com **8 GB de VRAM** é um bom ponto de partida para modelos de 7B. Para modelos maiores ou processamento mais rápido, 12 GB, 16 GB ou mais são ideais.
+    *   **AMD / Apple Silicon:** O Ollama tem um bom suporte para GPUs AMD (via ROCm) e para o Metal da Apple, tornando MacBooks com chips M1/M2/M3 excelentes máquinas para rodar modelos localmente.
+
+## 5. Sugestões de Modelos Open-Source (Ollama)
+
+*   **Para Codificação (Coding):**
+    *   `codellama`: Um clássico, treinado especificamente para código.
+    *   `deepseek-coder`: Frequentemente no topo dos benchmarks de codificação. É uma escolha excelente e muito poderosa.
+    *   `starcoder2`: A nova geração do Starcoder, com bom desempenho em várias linguagens.
+    *   `phi-3`: Um modelo menor da Microsoft, surpreendentemente capaz para seu tamanho e ótimo para máquinas com menos recursos.
+
+*   **Para Chat e Dúvidas Gerais (Chat):**
+    *   `llama3`: O Llama 3 da Meta é um dos melhores modelos de chat geral disponíveis hoje. A versão 8B é rápida e muito coerente.
+    *   `mistral`: Rápido e de alta qualidade, uma alternativa excelente ao Llama.
+    *   `qwen2`: Um modelo recente com forte capacidade multilíngue e bom raciocínio.
+
+*   **Qual modelo mais se aproxima do "Claude Code"?**
+    O "Claude 3 Opus" é um modelo proprietário de ponta, e igualá-lo com open-source é difícil, mas o que mais se aproxima em termos de capacidade de raciocínio complexo sobre código é provavelmente o **`deepseek-coder:33b`**. Ele é amplamente reconhecido pela sua performance de alto nível em tarefas de programação. Para uma experiência mais leve, mas ainda muito forte, o **`deepseek-coder:6.7b`** também é uma aposta fantástica.

docs/AI Coding/GUIA_CONTINUE_DEV_vs_COPILOT.md

@@ -0,0 +1,132 @@
+# Guia Alternativo: VSCode com Continue.dev vs. GitHub Copilot
+
+Este documento serve como um guia para utilizar o `Continue.dev` no VSCode, oferecendo um plano para as mesmas tarefas do guia anterior e um comparativo direto com o GitHub Copilot.
+
+`Continue.dev` é uma extensão open-source que transforma seu IDE em uma ferramenta de desenvolvimento assistida por LLMs, com foco em flexibilidade, privacidade e customização.
+
+## 1. Plano de Tarefas com Continue.dev
+
+A configuração do `Continue.dev` é centralizada em um único arquivo Python (`~/.continue/config.py`), o que permite um controle muito granular.
+
+**Passo-a-passo geral:**
+
+1.  Instale a extensão `Continue` a partir do VSCode Marketplace.
+2.  Abra o painel do Continue e clique no ícone de engrenagem ou use o comando `Ctrl/Cmd + L` e digite `> config` para abrir o arquivo `config.py`.
+3.  Edite o arquivo `config.py` com as configurações desejadas.
+
+---
+
+### a. Configurando com OpenRouter
+
+Adicione um modelo do OpenRouter à lista de modelos no seu `config.py`.
+
+```python
+from continuedev.core.config import Config
+from continuedev.core.models import Models
+from continuedev.libs.llm.openrouter import OpenRouter
+
+# ... outras importações
+
+config = Config(
+    models=Models(
+        default=OpenRouter(
+            api_key="YOUR_OPENROUTER_API_KEY",
+            model="mistralai/mistral-7b-instruct-free" # Ou outro modelo de sua escolha
+        )
+    )
+)
+```
+
+### b. Configurando com Ollama (Local e WSL)
+
+Execute modelos na sua própria máquina para ter total privacidade e zero custo de API.
+
+```python
+from continuedev.core.config import Config
+from continuedev.core.models import Models
+from continuedev.libs.llm.ollama import Ollama
+
+# ...
+
+config = Config(
+    models=Models(
+        default=Ollama(model="codellama") # Garanta que o modelo foi baixado com `ollama pull codellama`
+    )
+)
+```
+**Para WSL:** O princípio é o mesmo. Se o seu servidor Ollama estiver rodando dentro do WSL, o `Continue.dev` (rodando no VSCode conectado ao WSL) irá encontrá-lo em `localhost` sem configurações adicionais.
+
+### c. Configurando com um Proxy
+
+`Continue.dev` respeita variáveis de ambiente padrão como `HTTP_PROXY` e `HTTPS_PROXY`. Alternativamente, você pode especificar uma `api_base` para provedores que a suportam.
+
+**Método 1: Variáveis de Ambiente (Recomendado)**
+
+No seu terminal, antes de iniciar o VSCode:
+```bash
+export HTTPS_PROXY="http://SEU_PROXY_HOST:PORTA"
+code .
+```
+
+**Método 2: `api_base` (Para OpenAI e compatíveis)**
+
+```python
+from continuedev.core.config import Config
+from continuedev.core.models import Models
+from continuedev.libs.llm.openai import OpenAI
+
+# ...
+
+config = Config(
+    models=Models(
+        default=OpenAI(
+            api_key="YOUR_OPENAI_API_KEY",
+            model="gpt-4o",
+            api_base="https://SUA_URL_DE_PROXY/v1" # Endereço do proxy
+        )
+    )
+)
+```
+
+## 2. Comparativo: Continue.dev vs. GitHub Copilot
+
+| Característica | GitHub Copilot | Continue.dev |
+| :--- | :--- | :--- |
+| **Modelos Suportados** | Modelos proprietários da OpenAI (GPT-3.5, GPT-4) otimizados pela Microsoft. | Quase qualquer modelo: Ollama, OpenAI, Gemini, Claude, OpenRouter, etc. |
+| **Custo** | Assinatura paga (mensal/anual). | A extensão é gratuita. O custo é o da API do modelo que você escolher (ou zero, se usar Ollama local). |
+| **Código-Fonte** | Fechado. | **Aberto (Open-Source)**. |
+| **Privacidade** | O código é enviado aos servidores da Microsoft (com políticas de privacidade). | **Controle total.** Com modelos locais (Ollama), nada sai da sua máquina. |
+| **Customização** | Baixa. Algumas opções de configuração e exclusão de arquivos. | **Extremamente alta.** Configuração via Python, criação de comandos (`/slash_commands`), customização de contexto. |
+| **Gerenciamento de Contexto** | Automático, baseado nos arquivos abertos. | **Explícito e poderoso.** Use `@` para adicionar arquivos, pastas, documentação, problemas do GitHub e mais ao contexto. |
+| **Interface do Usuário** | Foco em autocompletar *inline*. Um painel de chat separado (`Copilot Chat`). | Foco no painel de chat interativo, com autocompletar *inline* como um recurso complementar. |
+| **Configuração Inicial**| "Funciona ao ligar" (Out-of-the-box). Praticamente nenhuma configuração. | Requer configuração inicial no arquivo `config.py` para escolher e autenticar seus modelos. |
+
+
+## 3. Plano de Migração: Do Copilot para o Continue.dev
+
+Migrar é um processo simples e direto:
+
+1.  **Instale o Continue.dev:** Procure por "Continue" no VSCode Marketplace e instale a extensão.
+2.  **Desabilite o GitHub Copilot:** Para evitar conflitos de atalhos e sugestões duplicadas, é altamente recomendado desabilitar ou desinstalar as extensões `GitHub Copilot` e `GitHub Copilot Chat`. Vá para a aba de Extensões, encontre o Copilot e clique em `Disable (Workspace)`.
+3.  **Configure seu Primeiro Modelo:** Siga as instruções da **Seção 1** deste guia para configurar seu `config.py` com o provedor de sua escolha (Ollama é um ótimo ponto de partida por ser gratuito e local).
+4.  **Aprenda o Fluxo de Trabalho:**
+    *   Use `Ctrl + L` para abrir a caixa de diálogo do Continue.
+    *   Use `Ctrl + J` (ou o atalho que configurar) para abrir o painel de chat.
+    *   Digite `/` no chat para ver os comandos disponíveis (ex: `/edit`, `/fix`, `/test`).
+    *   Digite `@` para ver os provedores de contexto (ex: `@file`, `@terminal`, `@docs`).
+
+## 4. Análise: Ganhos e Perdas na Migração
+
+### O que você GANHA com a migração para o Continue.dev:
+
+1.  **Flexibilidade Total:** Você não fica preso a um único provedor. Pode usar o melhor modelo para cada tarefa, seja ele open-source, da Google, Anthropic ou OpenAI.
+2.  **Controle Absoluto e Privacidade:** A capacidade de rodar 100% localmente com Ollama é um ganho imenso para empresas com políticas de privacidade restritas ou para desenvolvedores que não querem que seu código saia da máquina.
+3.  **Potencial de Custo Zero:** Ao usar modelos locais, o único custo é o do seu próprio hardware.
+4.  **Customização Profunda:** A capacidade de criar seus próprios comandos e automatizar fluxos de trabalho no `config.py` permite adaptar a ferramenta exatamente às suas necessidades.
+5.  **Gerenciamento de Contexto Superior:** O sistema de `@` do Continue é mais explícito e poderoso que o gerenciamento automático do Copilot, permitindo que você construa um contexto muito preciso para o LLM.
+
+### O que você PERDE (ou o que muda):
+
+1.  **A Experiência "Mágica" do Autocomplete:** O autocompletar *inline* do GitHub Copilot é extremamente polido e bem integrado. Embora o Continue.dev também ofereça autocomplete, a experiência do Copilot é frequentemente considerada o padrão ouro em termos de fluidez.
+2.  **Simplicidade "Out-of-the-Box":** O Copilot exige quase zero configuração. O Continue.dev tem uma curva de aprendizado inicial, exigindo que você configure seu primeiro modelo no `config.py`.
+3.  **Modelo "Tudo-em-Um" Otimizado:** Com o Copilot, você recebe um modelo de alta qualidade que a Microsoft otimizou para tarefas de codificação. Com o Continue, a qualidade da assistência depende inteiramente do modelo que *você* escolhe e configura.

mcphub/.config/mcphub/servers.json

@@ -1,5 +1,14 @@
 {
   "mcpServers": {
+    "time-docker": {
+      "command": "docker",
+      "args": [
+        "run",
+        "-i",
+        "--rm",
+        "mcp/time"
+      ]
+    },
     "context7": {
       "disabled": false,
       "headers": {
@@ -14,6 +23,10 @@
         "Authorization": "Bearer ${GITHUB_PERSONAL_ACCESS_TOKEN}"
       },
       "url": "https://api.githubcopilot.com/mcp/"
+    },
+    "playwright": {
+      "command": "npx",
+      "args": ["@playwright/mcp@latest"]
     }
   }
 }

vscode/.config/Code/User/mcp.json

@@ -0,0 +1,32 @@
+{
+  "servers": {
+    "time": {
+      "command": "docker",
+      "args": [
+        "run", 
+        "-i", 
+        "--rm", 
+        "mcp/time"
+      ]
+    },
+    "context7": {
+      "disabled": false,
+      "headers": {
+        "Accept": "application/json, text/event-stream",
+        "CONTEXT7_API_KEY": "${CONTEXT7_API_KEY}"
+      },
+      "url": "https://mcp.context7.com/mcp"
+    },
+    "github": {
+      "disabled": false,
+      "headers": {
+        "Authorization": "Bearer ${GITHUB_PERSONAL_ACCESS_TOKEN}"
+      },
+      "url": "https://api.githubcopilot.com/mcp/"
+    },
+    "playwright": {
+      "command": "npx",
+      "args": ["@playwright/mcp@latest"]
+    }
+  }
+}

vscode/README.md

@@ -0,0 +1,33 @@
+# VSCODE CONFIGS
+
+
+## Using XDG
+
+No Linux, o Visual Studio Code segue o padrão XDG Base Directory para armazenar as configurações do usuário e dados da aplicação. 
+Os caminhos padrão são: 
+
+**1. Configurações de Usuário (XDG_CONFIG_HOME)**
+
+Os arquivos de configuração (como o `settings.json` e `keybindings.json`) ficam no diretório definido pela variável `$XDG_CONFIG_HOME`. Se esta variável não estiver definida, o padrão é `$HOME/.config`. 
+
+- Caminho: `$HOME/.config/Code/User/`.
+- Versão OSS: Se você usa o VS Code Open Source (code-oss), o caminho costuma ser `$HOME/.config/Code - OSS/User/` ou `~/.config/vscode-oss/`. 
+
+**2. Cache (XDG_CACHE_HOME)** 
+
+- Arquivos temporários e cache de ferramentas (como o C++) são armazenados no diretório de cache. 
+- Caminho: $HOME/.cache/Code/ ou $XDG_CACHE_HOME/vscode-cpptools/. 
+
+**3. Dados e Extensões (XDG_DATA_HOME)**
+
+Embora o VS Code tradicionalmente use `~/.vscode/extensions` para extensões, versões baseadas em servidor ou implementações estritas do padrão XDG podem mover dados para o diretório de dados. 
+- Caminho: $HOME/.local/share/Code/. 
+
+**Resumo dos principais arquivos no padrão XDG:**
+
+| Tipo de Arquivo | Localização Padrão (Linux) |
+|-----------------|----------------------------|
+| Configurações (JSON) |	~/.config/Code/User/settings.json |
+| Atalhos de Teclado |	~/.config/Code/User/keybindings.json |
+| Snippets de Usuário |	~/.config/Code/User/snippets/ |
+| Configurações MCP	| ~/.vscode/mcp.json (dentro do workspace) |