claudio-agent 2.0.0__tar.gz

claudio_agent-2.0.0/.claudio/skills/skill.md

@@ -0,0 +1,1604 @@
+# claudio - Agente Autônomo de Programação via Terminal
+
+## Descrição
+Skill para recriar o **claudio**, um agente autônomo de programação que roda no terminal. Usa API OpenAI com `rich` para interface. Permite criar projetos, analisar código, debugar, editar/refatorar arquivos, buscar na web, comandos git, modo autônomo multi-passo, troca de modelo, auto-instalar dependências, skills, RULES, chat normal e persistência de sessão.
+
+## Estrutura do Projeto
+
+```
+opoenClaudio/
+├── .env                       # Chave da API OpenAI
+├── claudio.py                 # Script principal do agente
+├── claudio.md                 # Documentação
+├── opencode.md                # Documentação opencode
+├── README.md                  # Guia de início rápido
+├── pyproject.toml             # Pacote Python (pip install claudio-agent)
+├── requirements.txt           # Dependências Python
+├── MANIFEST.in                # Inclui .claudio/ e claudio.md no pacote
+├── .gitignore                 # Exclui .env, __pycache__, etc.
+├── package.json               # Scripts locais (privado, sem publish)
+├── scripts/
+│   ├── build-exe.js           # Build PyInstaller
+│   └── publish-pypi.py        # Publica no PyPI
+├── .claudio/
+│   ├── skills/
+│   │   └── skill.md           # Esta skill (auto-reconstrução)
+│   └── RULES/                 # Regras carregadas no contexto (opcional)
+├── .claudio_history.json      # Histórico de sessão (gerado automaticamente)
+└── .opencode/
+    └── SKILL.md               # Skill opencode (cópia)
+```
+
+## Dependências
+
+- Python 3.10+
+- `openai` - Cliente da API OpenAI
+- `rich` - Interface estilizada no terminal
+
+Instalação:
+```bash
+pip install openai rich
+```
+
+## Arquivos Necessários
+
+### 1. `.env` — Chave da API
+
+```
+API_KEY = "sk-proj-..."
+```
+
+> ⚠️ Substitua pela sua chave real da OpenAI. A API key também pode ser definida via variável de ambiente `API_KEY`.
+
+### 2. `claudio.py` — Script Principal
+
+[Ver conteúdo completo no final](#código-completo-do-claudiopy)
+
+### 3. Comando no PATH (opcional)
+
+Criar `claudio.cmd` em um diretório que esteja no `PATH`:
+```cmd
+@echo off
+python "C:\Users\Claudio\Desktop\opoenClaudio\claudio.py" %*
+```
+
+## Funcionalidades
+
+| Comando | Descrição |
+|---------|-----------|
+| `analisar projeto` | Analisa todo o projeto |
+| `analisar <arquivo/pasta>` | Analisa um alvo específico |
+| `listar` / `ls` | Lista arquivos da pasta atual |
+| `ler <arquivo>` | Mostra o conteúdo de um arquivo |
+| `editar <arquivo> <desc>` | Edita arquivo via IA (mostra diff) |
+| `refatorar <arquivo>` | Refatora código (mostra diff) |
+| `debug <arquivo> <erro>` | Debuga um arquivo com erro |
+| `executar <comando>` | Executa comando no terminal |
+| `git <args>` | Executa comandos git |
+| `buscar <query>` | Busca na internet |
+| `site <url>` | Acessa conteúdo de uma URL |
+| `crie/criar/gere/faça/desenvolva <desc>` | Gera um projeto completo via IA |
+| `autonomo/missao <desc>` | Modo autônomo multi-passo |
+| `modelo <nome>` | Troca o modelo GPT |
+| `config` | Altera chave API e modelo |
+| `instalar/deps` | Auto-instala dependências Python |
+| `salvar` | Salva o histórico da sessão |
+| `carregar` | Carrega a última sessão |
+| `skill <nome>` | Executa skill (do .claudio/skills/ ou caminho) |
+| `skills` | Lista skills disponíveis |
+| `executar skill <nome>` | Executa uma skill (cria novo projeto) |
+| `aplicar skill <nome>` | Aplica skill no projeto existente |
+| `/help` | Mostra ajuda |
+| `/exit` | Sai do programa |
+| *(qualquer outra coisa)* | Chat normal com a IA |
+
+## Como Reconstruir
+
+1. Crie a pasta do projeto
+2. Crie o arquivo `.env` com sua chave da OpenAI
+3. Crie `claudio.py` com o código completo abaixo
+4. Instale as dependências: `pip install openai rich`
+5. Execute: `python claudio.py` ou `claudio` (se instalado via pip)
+6. Na primeira execução: escolha o modelo e insira sua chave
+7. Coloque skills em `.claudio/skills/` ou `~/.claudio/skills/`
+
+### Onde o agente busca arquivos
+
+O agente carrega `claudio.md` e `.claudio/` (skills/rules) nesta ordem:
+1. **WORKSPACE** (diretório atual) — maior prioridade
+2. **PACKAGE_DIR** (onde `claudio.py` está instalado)
+3. **~/.claudio/** (diretório home do usuário) — fallback
+
+## Código Completo do `claudio.py`
+
+```python
+import os
+import sys
+import json
+import re
+import subprocess
+import io
+import datetime
+import urllib.request
+import urllib.parse
+from pathlib import Path
+from openai import OpenAI
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.prompt import Prompt
+from rich.status import Status
+from rich.table import Table
+from rich.style import Style
+from rich import box
+
+if sys.platform == "win32":
+    os.system("chcp 65001 > nul")
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
+    sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace")
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+HOME_DIR = Path.home()
+CONFIG_DIR = HOME_DIR / ".claudio"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+AVAILABLE_MODELS = [
+    "gpt-4.1-mini", "gpt-4o-mini", "gpt-4o", "gpt-4-turbo", "gpt-3.5-turbo"
+]
+MAX_TOKENS = 8000
+TEMPERATURE = 0.1
+MAX_FILE_SIZE = 500000
+MAX_CONTEXT_CHARS = 400000
+MAX_FILE_PREVIEW = 2000
+HISTORY_FILE = Path(".claudio_history.json")
+WORKSPACE = Path.cwd()
+
+console = Console()
+
+def load_config():
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+        except Exception:
+            pass
+    return {}
+
+def save_config(data):
+    try:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        existing = load_config()
+        existing.update(data)
+        CONFIG_FILE.write_text(json.dumps(existing, ensure_ascii=False, indent=2), encoding="utf-8")
+    except Exception as e:
+        console.print(f"[yellow]⚠️  Erro ao salvar config: {e}[/]")
+
+def setup_wizard():
+    console.print(Panel(
+        "[bold]Bem-vindo ao claudio![/]\n\n"
+        "Precisamos configurar sua chave da OpenAI antes de começar.\n"
+        "[dim]Você pode obter uma chave em: https://platform.openai.com/api-keys[/]",
+        title="[bold cyan]⚙️ Configuração Inicial[/]",
+        border_style="cyan",
+        box=box.ROUNDED,
+        padding=(1, 2)
+    ))
+
+    key = Prompt.ask("[bold yellow]🔑 Digite sua API Key da OpenAI[/]", password=True)
+    while not key or not key.startswith("sk-"):
+        console.print("[red]❌ Chave inválida. Deve começar com 'sk-'[/]")
+        key = Prompt.ask("[bold yellow]🔑 Digite sua API Key da OpenAI[/]", password=True)
+
+    save_config({"api_key": key})
+
+    console.print("[green]✅ Chave salva em ~/.claudio/config.json[/]")
+
+    console.print("\n[bold]Modelos disponíveis:[/]")
+    for i, m in enumerate(AVAILABLE_MODELS, 1):
+        console.print(f"  [cyan]{i}.[/] {m}")
+    model_idx = Prompt.ask("[bold yellow]🎯 Escolha o modelo padrão[/]", choices=[str(i) for i in range(1, len(AVAILABLE_MODELS)+1)], default="1")
+    chosen_model = AVAILABLE_MODELS[int(model_idx) - 1]
+    save_config({"model": chosen_model})
+    console.print(f"[green]✅ Modelo padrão: {chosen_model}[/]")
+
+    return key, chosen_model
+
+API_KEY = os.getenv("API_KEY")
+MODEL = "gpt-4.1-mini"
+
+if not API_KEY:
+    for env_path in [
+        SCRIPT_DIR / ".env",
+        Path.cwd() / ".env",
+        HOME_DIR / ".claudio.env",
+        HOME_DIR / ".claudio" / ".env"
+    ]:
+        if env_path.exists():
+            try:
+                raw = env_path.read_text(encoding="utf-8", errors="ignore")
+                API_KEY = raw.split("=", 1)[1].strip().strip("\"'").strip()
+                if API_KEY:
+                    break
+            except Exception:
+                pass
+
+if not API_KEY:
+    cfg = load_config()
+    API_KEY = cfg.get("api_key") or ""
+    MODEL = cfg.get("model") or MODEL
+
+if not API_KEY:
+    API_KEY, MODEL = setup_wizard()
+
+client = OpenAI(api_key=API_KEY, timeout=120)
+
+IGNORE_DIRS = {
+    "venv", ".git", "__pycache__", "node_modules",
+    ".dart_tool", "build", "dist", ".idea", ".vscode",
+    ".opencode", ".claudio"
+}
+
+SUPPORTED_EXTENSIONS = {
+    ".py", ".js", ".ts", ".tsx", ".jsx",
+    ".dart", ".html", ".css", ".json", ".md", ".txt",
+    ".yaml", ".yml", ".toml", ".cfg", ".ini", ".conf",
+    ".bat", ".ps1", ".sh", ".env", ".sql", ".xml",
+    ".java", ".cpp", ".c", ".h", ".hpp", ".rb", ".go",
+    ".rs", ".swift", ".kt", ".scala", ".php", ".r",
+    ".lua", ".pl", ".pm", ".vue", ".svelte", ".astro",
+    ".mjs", ".cjs", ".mts", ".cts"
+}
+
+USER_STYLE = Style(color="cyan", bold=True)
+AI_STYLE = Style(color="green", bold=True)
+ERROR_STYLE = Style(color="red", bold=True)
+INFO_STYLE = Style(color="yellow", bold=True)
+SYSTEM_STYLE = Style(color="magenta", bold=True)
+
+chat_history = []
+
+CLAUDIO_MD = ""
+claudio_md_path = WORKSPACE / "claudio.md"
+if claudio_md_path.exists():
+    try:
+        CLAUDIO_MD = claudio_md_path.read_text(encoding="utf-8", errors="ignore")
+    except:
+        pass
+
+CLAUDIO_SKILLS = []
+CLAUDIO_SKILLS_TEXT = ""
+CLAUDIO_RULES = ""
+CLAUDIO_DIR = WORKSPACE / ".claudio"
+
+if CLAUDIO_DIR.exists():
+    skills_dir = CLAUDIO_DIR / "skills"
+    if skills_dir.exists():
+        parts = []
+        for f in sorted(skills_dir.iterdir()):
+            if f.is_file() and f.suffix in SUPPORTED_EXTENSIONS:
+                try:
+                    c = f.read_text(encoding='utf-8', errors='ignore')[:MAX_FILE_PREVIEW]
+                    name = f.name
+                    CLAUDIO_SKILLS.append({"name": name, "content": c, "path": f})
+                    parts.append(f"// {f.name}\n{c}")
+                except:
+                    pass
+        if parts:
+            CLAUDIO_SKILLS_TEXT = "\n\n".join(parts)
+
+    rules_dir = CLAUDIO_DIR / "RULES"
+    if rules_dir.exists():
+        parts = []
+        for f in sorted(rules_dir.iterdir()):
+            if f.is_file() and f.suffix in SUPPORTED_EXTENSIONS:
+                try:
+                    parts.append(f"// {f.name}\n{f.read_text(encoding='utf-8', errors='ignore')[:MAX_FILE_PREVIEW]}")
+                except:
+                    pass
+        if parts:
+            CLAUDIO_RULES = "\n\n".join(parts)
+
+def session_save():
+    try:
+        data = {
+            "chat_history": chat_history[-200:],
+            "model": MODEL,
+            "timestamp": str(datetime.datetime.now())
+        }
+        HISTORY_FILE.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    except Exception as e:
+        pass
+
+def session_load():
+    global chat_history, MODEL
+    try:
+        if HISTORY_FILE.exists():
+            data = json.loads(HISTORY_FILE.read_text(encoding="utf-8"))
+            chat_history = data.get("chat_history", [])
+            saved_model = data.get("model")
+            if saved_model and saved_model in AVAILABLE_MODELS:
+                MODEL = saved_model
+            return True
+    except:
+        pass
+    return False
+
+def make_claudio_context() -> str:
+    parts = []
+    if CLAUDIO_MD:
+        parts.append(f"[claudio.md]\n{CLAUDIO_MD}")
+    if CLAUDIO_SKILLS_TEXT:
+        parts.append(f"[.claudio/skills]\n{CLAUDIO_SKILLS_TEXT}")
+    if CLAUDIO_RULES:
+        parts.append(f"[.claudio/RULES]\n{CLAUDIO_RULES}")
+    if not parts:
+        return ""
+    return "\n\n---\n\n".join(parts)
+
+def is_invalid_response(text: str):
+    if not text:
+        return True
+    if len(text) > 500000:
+        return True
+    if re.fullmatch(r"(.)\1{500,}", text):
+        return True
+    return False
+
+def write_file(file_path: str, content: str):
+    try:
+        if len(content) > MAX_FILE_SIZE:
+            console.print(f"[red]❌ Arquivo muito grande: {file_path}[/]")
+            return False
+        full_path = WORKSPACE / file_path
+        full_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(full_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        console.print(f"[green]✅ Arquivo criado: [bold]{file_path}[/][/]")
+        return True
+    except Exception as e:
+        console.print(f"[red]❌ Erro ao criar arquivo: {e}[/]")
+        return False
+
+def read_file(file_path: str):
+    try:
+        p = Path(file_path)
+        full_path = p if p.is_absolute() else WORKSPACE / file_path
+        if not full_path.exists():
+            return None
+        with open(full_path, "r", encoding="utf-8", errors="ignore") as f:
+            return f.read()
+    except Exception as e:
+        console.print(f"[red]❌ Erro ao ler arquivo: {e}[/]")
+        return None
+
+def get_project_structure():
+    structure = []
+    for root, dirs, files in os.walk(WORKSPACE):
+        dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
+        level = root.replace(str(WORKSPACE), "").count(os.sep)
+        indent = " " * 4 * level
+        structure.append(f"{indent}{Path(root).name}/")
+        subindent = " " * 4 * (level + 1)
+        for file in files:
+            structure.append(f"{subindent}{file}")
+    return "\n".join(structure)
+
+def get_project_context():
+    context = []
+    total_chars = 0
+
+    claudio_md_path = WORKSPACE / "claudio.md"
+    if claudio_md_path.exists():
+        try:
+            c = claudio_md_path.read_text(encoding="utf-8", errors="ignore")[:MAX_FILE_PREVIEW]
+            if c:
+                context.append(f"\n\nARQUIVO: {claudio_md_path}\n\n{c}")
+                total_chars += len(c)
+        except:
+            pass
+
+    claudio_dir = WORKSPACE / ".claudio"
+
+    skills_dir = claudio_dir / "skills"
+    if skills_dir.exists():
+        for f in sorted(skills_dir.iterdir()):
+            if f.is_file() and f.suffix in SUPPORTED_EXTENSIONS:
+                if total_chars >= MAX_CONTEXT_CHARS:
+                    context.append(f"\n\n... [limite de {MAX_CONTEXT_CHARS} caracteres atingido]")
+                    break
+                try:
+                    c = f.read_text(encoding="utf-8", errors="ignore")[:MAX_FILE_PREVIEW]
+                    context.append(f"\n\nARQUIVO: {f}\n\n{c}")
+                    total_chars += len(c)
+                except:
+                    pass
+
+    rules_dir = claudio_dir / "RULES"
+    if rules_dir.exists():
+        for f in sorted(rules_dir.iterdir()):
+            if f.is_file() and f.suffix in SUPPORTED_EXTENSIONS:
+                if total_chars >= MAX_CONTEXT_CHARS:
+                    context.append(f"\n\n... [limite de {MAX_CONTEXT_CHARS} caracteres atingido]")
+                    break
+                try:
+                    c = f.read_text(encoding="utf-8", errors="ignore")[:MAX_FILE_PREVIEW]
+                    context.append(f"\n\nARQUIVO: {f}\n\n{c}")
+                    total_chars += len(c)
+                except:
+                    pass
+
+    def priority(suffix):
+        return 0 if suffix == ".py" else 1 if suffix in (".js", ".ts", ".tsx", ".jsx") else 2 if suffix in (".json", ".md", ".toml", ".yaml", ".yml") else 3
+    file_list = []
+    for root, dirs, files in os.walk(WORKSPACE):
+        dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
+        for file in files:
+            path = Path(root) / file
+            if path.suffix in SUPPORTED_EXTENSIONS and path != claudio_md_path and not str(path).startswith(str(claudio_dir)):
+                try:
+                    size = path.stat().st_size
+                    file_list.append((priority(path.suffix), size, path))
+                except:
+                    pass
+    file_list.sort(key=lambda x: (x[0], x[1]))
+    for _, _, path in file_list:
+        try:
+            content = path.read_text(encoding="utf-8", errors="ignore")
+            content = content[:MAX_FILE_PREVIEW]
+            if total_chars + len(content) > MAX_CONTEXT_CHARS:
+                remaining = MAX_CONTEXT_CHARS - total_chars
+                if remaining > 200:
+                    context.append(f"\n\nARQUIVO: {path}\n\n{content[:remaining]}")
+                context.append(f"\n\n... [limite de {MAX_CONTEXT_CHARS} caracteres atingido, {len(file_list) - len(context)} arquivos restantes]")
+                break
+            context.append(f"\n\nARQUIVO: {path}\n\n{content}")
+            total_chars += len(content)
+        except:
+            pass
+    return "".join(context)
+
+def render_message(role: str, content: str):
+    if role == "user":
+        console.print(Panel(
+            content,
+            title="[bold cyan]Você[/]",
+            border_style="cyan",
+            box=box.ROUNDED,
+            padding=(1, 2)
+        ))
+    elif role == "assistant":
+        md = Markdown(content)
+        console.print(Panel(
+            md,
+            title="[bold green]claudio[/]",
+            border_style="green",
+            box=box.ROUNDED,
+            padding=(1, 2)
+        ))
+    elif role == "error":
+        console.print(Panel(
+            content,
+            title="[bold red]Erro[/]",
+            border_style="red",
+            box=box.ROUNDED,
+            padding=(1, 2)
+        ))
+    elif role == "system":
+        console.print(Panel(
+            content,
+            title="[bold yellow]Sistema[/]",
+            border_style="yellow",
+            box=box.ROUNDED,
+            padding=(1, 2)
+        ))
+    elif role == "info":
+        console.print(f"[yellow]ℹ️ {content}[/]")
+    elif role == "code":
+        syntax = Syntax(content, "python", theme="monokai", line_numbers=True)
+        console.print(Panel(
+            syntax,
+            title="[bold blue]Código[/]",
+            border_style="blue",
+            box=box.ROUNDED,
+            padding=(1, 2)
+        ))
+
+def normal_chat(user_message: str):
+    chat_history.append({"role": "user", "content": user_message})
+    try:
+        ctx = make_claudio_context()
+        messages = [{"role": "system", "content": f"""
+Você é um assistente de programação.
+REGRAS:
+- Responda normalmente
+- NÃO crie projetos
+- NÃO gere JSON
+- NÃO gere arquivos
+- NÃO gere pastas
+- Apenas converse
+{ctx}
+"""}]
+        for msg in chat_history[-20:]:
+            messages.append(msg)
+
+        with Status("[bold yellow]🤔 Pensando...", spinner="dots"):
+            response = client.chat.completions.create(
+                model=MODEL,
+                messages=messages,
+                temperature=0.3,
+                max_tokens=1000
+            )
+
+        content = response.choices[0].message.content
+        chat_history.append({"role": "assistant", "content": content})
+        render_message("assistant", content if content else "Sem resposta")
+        return content
+    except Exception as e:
+        error_msg = f"❌ {e}"
+        render_message("error", error_msg)
+        return error_msg
+
+def ask_ai(prompt: str):
+    try:
+        with Status("[bold yellow]🚀 Gerando...", spinner="dots"):
+            response = client.chat.completions.create(
+                model=MODEL,
+                response_format={"type": "json_object"},
+                messages=[
+                    {"role": "system", "content": """
+Você é um agente autônomo de programação.
+REGRAS:
+- Gere SOMENTE JSON válido
+- Nunca explique
+- Nunca use markdown
+- Nunca escreva fora do JSON
+- Gere arquivos completos
+Formato obrigatório:
+{
+  "files": [
+    {
+      "path": "arquivo.ext",
+      "content": "codigo"
+    }
+  ]
+}
+""" + (f"\n\n---\n{make_claudio_context()}" if CLAUDIO_MD or CLAUDIO_SKILLS_TEXT or CLAUDIO_RULES else "")},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=TEMPERATURE,
+                max_tokens=MAX_TOKENS
+            )
+        content = response.choices[0].message.content.strip()
+        if is_invalid_response(content):
+            return None
+        return content
+    except Exception as e:
+        console.print(f"[red]❌ Erro OpenAI: {e}[/]")
+        return None
+
+def extract_json(text: str):
+    try:
+        data = json.loads(text)
+        if "files" not in data or not isinstance(data["files"], list):
+            return None
+        return data
+    except Exception as e:
+        console.print(f"[red]❌ JSON inválido: {e}[/]")
+        return None
+
+def create_project(user_prompt: str):
+    console.print()
+    console.print(Panel(
+        "[bold]Planejando projeto...[/]",
+        title="[bold yellow]🚀 Criar Projeto[/]",
+        border_style="yellow",
+        box=box.ROUNDED
+    ))
+
+    ctx = make_claudio_context()
+    
+    with Status("[bold yellow]📋 Gerando plano...", spinner="dots"):
+        try:
+            plan_resp = client.chat.completions.create(
+                model=MODEL,
+                response_format={"type": "json_object"},
+                messages=[
+                    {"role": "system", "content": "Você é um arquiteto de projetos. Gere APENAS um plano em JSON, sem código." + ctx},
+                    {"role": "user", "content": f"""Crie um plano para este pedido:
+{user_prompt}
+
+Se for web (Vite, React, Next, Nest, etc), inclua package.json, configs, index.html no plano.
+
+Retorne JSON:
+{{"plano": "descrição do que será criado",
+  "arquivos": [
+    {{"path": "caminho/arquivo.ext", "descricao": "o que este arquivo faz", "linguagem": "python/arduino/html/etc"}}
+  ],
+  "total_estimado": 5}}"""}
+                ],
+                temperature=0.3,
+                max_tokens=1000
+            )
+            plan_data = json.loads(plan_resp.choices[0].message.content)
+            plano_desc = plan_data.get("plano", "")
+            arquivos_planejados = plan_data.get("arquivos", [])
+        except Exception as e:
+            render_message("error", f"Erro ao gerar plano: {e}")
+            return
+
+    if not arquivos_planejados:
+        render_message("error", "Não foi possível gerar um plano")
+        return
+
+    render_message("assistant", f"**📋 Plano:**\n\n{plano_desc}\n\n**Arquivos:**")
+    for af in arquivos_planejados:
+        path = af.get("path", "?")
+        desc = af.get("descricao", "")
+        lang = af.get("linguagem", "")
+        render_message("info", f"📄 [bold]{path}[/]  ([green]{lang}[/])  — {desc}")
+
+    confirm = Prompt.ask(
+        f"\n[bold yellow]Criar estes {len(arquivos_planejados)} arquivo(s)?[/]",
+        choices=["s", "n", "detalhar"],
+        default="s"
+    )
+
+    if confirm == "n":
+        render_message("info", "Criação cancelada")
+        return
+
+    if confirm == "detalhar":
+        det_data = None
+        with Status("[bold yellow]🔍 Gerando detalhes...", spinner="dots"):
+            try:
+                det_resp = client.chat.completions.create(
+                    model=MODEL,
+                    response_format={"type": "json_object"},
+                    messages=[
+                        {"role": "system", "content": "Gere JSON com plano detalhado." + ctx},
+                        {"role": "user", "content": f"""Detalhe o plano para: {user_prompt}
+
+Retorne JSON:
+{{"plano": "descrição detalhada da arquitetura",
+  "arquivos": [
+    {{"path": "...", "descricao": "...", "linguagem": "...", "dependencias": ["lib1"], "tamanho_estimado": "pequeno/médio/grande"}}
+  ]}}"""}
+                    ],
+                    temperature=0.3,
+                    max_tokens=1500
+                )
+                det_data = json.loads(det_resp.choices[0].message.content)
+            except Exception as e:
+                render_message("error", f"Erro ao detalhar: {e}")
+                return
+        if det_data:
+            render_message("assistant", f"**📋 Plano Detalhado:**\n\n{det_data.get('plano', '')}")
+            for af in det_data.get("arquivos", arquivos_planejados):
+                path = af.get("path", "?")
+                desc = af.get("descricao", "")
+                lang = af.get("linguagem", "")
+                deps = af.get("dependencias", [])
+                size = af.get("tamanho_estimado", "")
+                deps_str = f"  📦 {', '.join(deps)}" if deps else ""
+                render_message("info", f"📄 [bold]{path}[/]  ([green]{lang}[/], {size}) — {desc}{deps_str}")
+            if Prompt.ask("[bold yellow]Continuar com a criação?[/]", choices=["s", "n"], default="s") != "s":
+                render_message("info", "Criação cancelada")
+                return
+
+    render_message("info", "⏳ Gerando código dos arquivos...")
+
+    prompt = f"""
+Gere um projeto completo e funcional para:
+{user_prompt}
+
+REGRAS:
+- Inclua TODOS os arquivos necessários para o projeto rodar
+- Para projetos web (Vite, React, Next.js, NestJS, etc), inclua:
+  - package.json com TODAS as dependências necessárias
+  - vite.config.js ou next.config.js ou similar
+  - index.html (se aplicável)
+  - tsconfig.json ou jsconfig.json (se aplicável)
+  - Todos os arquivos de src/ necessários
+- Gere código completo e funcional
+- Crie a estrutura de pastas adequada para o framework
+"""
+
+    response = ask_ai(prompt)
+    if not response:
+        render_message("error", "Falha na resposta da IA")
+        return
+
+    data = extract_json(response)
+    if not data:
+        render_message("error", "JSON inválido")
+        return
+
+    files = data.get("files", [])
+    if not files:
+        render_message("error", "Nenhum arquivo retornado")
+        return
+
+    total = 0
+    for file_data in files:
+        path = file_data.get("path")
+        content = file_data.get("content")
+        if not path or not content:
+            continue
+        if write_file(path, content):
+            total += 1
+
+    render_message("info", f"✅ {total} arquivos criados")
+
+    has_package_json = any(f.get("path", "").endswith("package.json") for f in files)
+
+    if has_package_json:
+        render_message("info", "📦 package.json detectado")
+        if Prompt.ask("[bold yellow]Instalar dependências com npm?[/]", choices=["s", "n"], default="s") == "s":
+            with Status("[bold yellow]📦 Instalando dependências...", spinner="dots"):
+                r = subprocess.run("npm install", shell=True, capture_output=True, text=True, cwd=WORKSPACE)
+                if r.returncode == 0:
+                    render_message("info", "✅ Dependências instaladas")
+                else:
+                    render_message("error", f"npm install falhou: {r.stderr.strip()[:300]}")
+
+            if Prompt.ask("[bold yellow]Iniciar servidor de desenvolvimento?[/]", choices=["s", "n"], default="n") == "s":
+                render_message("info", "🚀 Abrindo servidor em novo terminal...")
+                if sys.platform == "win32":
+                    subprocess.Popen("start cmd /k npm run dev", shell=True, cwd=WORKSPACE)
+                else:
+                    subprocess.Popen("x-terminal-emulator -e npm run dev", shell=True, cwd=WORKSPACE)
+                render_message("info", "✅ Servidor iniciado em janela separada")
+
+        has_next = any("next" in f.get("path", "") or "next" in f.get("content", "").lower()[:200] for f in files)
+        has_vite = any("vite" in f.get("path", "") or "vite" in f.get("content", "").lower()[:200] for f in files)
+
+        if has_next:
+            render_message("info", "💡 Próximos passos: cd na pasta e `npm run dev`")
+        elif has_vite:
+            render_message("info", "💡 Próximos passos: `npm run dev` para iniciar o Vite")
+        else:
+            render_message("info", "💡 Próximos passos: veja o package.json para scripts disponíveis")
+
+def analyze_code(file_path: str):
+    content = read_file(file_path)
+    if not content:
+        return "❌ Arquivo não encontrado"
+
+    extension = file_path.split(".")[-1] if "." in file_path else "txt"
+
+    ctx = make_claudio_context()
+    system_msg = {
+        "role": "system",
+        "content": "Você é um analisador de código. Responda SEMPRE em português. Analise o código abaixo.\n\n" + ctx
+    }
+    prompt = f"```{extension}\n{content[:4000]}\n```\n\nAnalise o código acima. Responda em português."
+
+    try:
+        with Status("[bold yellow]🔍 Analisando código...", spinner="dots"):
+            response = client.chat.completions.create(
+                model=MODEL,
+                messages=[system_msg, {"role": "user", "content": prompt}],
+                temperature=0.2,
+                max_tokens=2000
+            )
+        result = response.choices[0].message.content
+        render_message("assistant", result)
+        return result
+    except Exception as e:
+        error_msg = f"❌ {e}"
+        render_message("error", error_msg)
+        return error_msg
+
+def analyze_project():
+    console.print()
+    render_message("info", "Analisando projeto completo...")
+    context = get_project_context()
+
+    ctx = make_claudio_context()
+    system_msg = {
+        "role": "system",
+        "content": "Você é um analisador de código. Responda SEMPRE em português. Analise o projeto abaixo.\n\n" + ctx
+    }
+    prompt = f"""```\n{context}\n```
+
+Analise este projeto. Responda em português:
+- arquitetura
+- bugs e problemas de segurança
+- code smells
+- arquivos importantes
+- sugestões de melhoria
+"""
+
+    try:
+        with Status("[bold yellow]🔍 Analisando projeto...", spinner="dots"):
+            response = client.chat.completions.create(
+                model=MODEL,
+                messages=[system_msg, {"role": "user", "content": prompt}],
+                temperature=0.2,
+                max_tokens=4000
+            )
+        result = response.choices[0].message.content
+        render_message("assistant", result)
+    except Exception as e:
+        render_message("error", f"{e}")
+
+def debug_code(file_path: str, error: str):
+    content = read_file(file_path)
+    if not content:
+        return "❌ Arquivo não encontrado"
+
+    extension = file_path.split(".")[-1] if "." in file_path else "txt"
+    prompt = f"Corrija este código.\n\nErro:\n{error}\n\nArquivo:\n{file_path}\n\n```{extension}\n{content[:4000]}\n```"
+
+    try:
+        with Status("[bold yellow]🐛 Debugando...", spinner="dots"):
+            response = client.chat.completions.create(
+                model=MODEL,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.1,
+                max_tokens=3000
+            )
+        result = response.choices[0].message.content
+        render_message("assistant", result)
+        return result
+    except Exception as e:
+        error_msg = f"❌ {e}"
+        render_message("error", error_msg)
+        return error_msg
+
+def list_directory(path: str = "."):
+    try:
+        target = WORKSPACE / path
+        if not target.exists():
+            render_message("error", f"Pasta não encontrada: {path}")
+            return None
+        if not target.is_dir():
+            return None
+
+        tree = []
+        for root, dirs, files in os.walk(target):
+            dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
+            rel = Path(root).relative_to(target)
+            level = len(rel.parts)
+            indent = " " * 4 * level
+            if level == 0:
+                tree.append(f"{target.name}/")
+            else:
+                tree.append(f"{indent}{rel.name}/")
+            subindent = " " * 4 * (level + 1)
+            for f in sorted(files):
+                tree.append(f"{subindent}{f}")
+
+        result = "\n".join(tree)
+        render_message("code", result)
+        return result
+    except Exception as e:
+        render_message("error", f"{e}")
+        return None
+
+def analyze_folder(folder_path: str):
+    target = Path(folder_path)
+    if not target.is_absolute():
+        target = WORKSPACE / folder_path
+
+    if not target.exists():
+        render_message("error", f"Pasta não encontrada: {target}")
+        return
+    if not target.is_dir():
+        analyze_code(str(target))
+        return
+
+    render_message("info", f"[bold]> Pasta alvo:[/] {target}")
+    render_message("info", f"[bold]> Lendo arquivos...[/]")
+
+    files_content = []
+    total_chars = 0
+    total_read = 0
+    skipped = 0
+    for root, dirs, files in os.walk(target):
+        dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
+        for file in sorted(files):
+            fpath = Path(root) / file
+            if fpath.suffix not in SUPPORTED_EXTENSIONS:
+                continue
+            try:
+                content = fpath.read_text(encoding="utf-8", errors="ignore")
+                rel = fpath.relative_to(WORKSPACE) if target != WORKSPACE else fpath.relative_to(target)
+                if len(content) > MAX_FILE_PREVIEW:
+                    content = content[:MAX_FILE_PREVIEW] + "\n// ... [TRUNCADO]"
+                if total_chars + len(content) > MAX_CONTEXT_CHARS:
+                    skipped += 1
+                    continue
+                files_content.append(f"// {rel}\n{content}")
+                total_chars += len(content)
+                total_read += 1
+            except:
+                pass
+
+    if not files_content:
+        render_message("error", "Nenhum arquivo suportado encontrado nesta pasta")
+        return
+
+    msg = f"[bold]> {total_read} arquivos lidos[/]"
+    if skipped:
+        msg += f" ([yellow]{skipped} ignorados por limite de tamanho[/])"
+    render_message("info", msg)
+
+    code_block = "\n\n".join(files_content)
+
+    ctx = make_claudio_context()
+    system_msg = {
+        "role": "system",
+        "content": "Você é um analisador de código. Responda SEMPRE em português. Analise o código abaixo.\n\n" + ctx
+    }
+
+    prompt = f"""{code_block}
+
+---
+
+Revise cada trecho acima. Para cada um:
+- o que faz
+- bugs, problemas de segurança, code smells
+- melhorias
+
+Depois, análise geral:
+- propósito do conjunto
+- arquitetura
+- pontos fortes/fracos
+- sugestões de refatoração
+"""
+
+    try:
+        with Status("[bold yellow]🔍 Analisando pasta...", spinner="dots"):
+            response = client.chat.completions.create(
+                model=MODEL,
+                messages=[system_msg, {"role": "user", "content": prompt}],
+                temperature=0.2,
+                max_tokens=6000
+            )
+        result = response.choices[0].message.content
+        render_message("assistant", result)
+    except Exception as e:
+        render_message("error", f"{e}")
+
+def read_file_content(file_path: str):
+    content = read_file(file_path)
+    if content is None:
+        render_message("error", f"Arquivo não encontrado: {file_path}")
+        return
+    syntax = Syntax(content, file_path.split(".")[-1] if "." in file_path else "txt",
+                     theme="monokai", line_numbers=True)
+    console.print(Panel(
+        syntax,
+        title=f"[bold blue]{file_path}[/]",
+        border_style="blue",
+        box=box.ROUNDED,
+        padding=(1, 2)
+    ))
+
+def run_terminal(command: str):
+    try:
+        with Status("[bold yellow]⚡ Executando...", spinner="dots"):
+            result = subprocess.run(
+                command, shell=True, capture_output=True, text=True, cwd=WORKSPACE
+            )
+        if result.stdout:
+            console.print(Panel(
+                result.stdout.strip() or "(sem output)",
+                title="[bold green]Output[/]",
+                border_style="green",
+                box=box.ROUNDED,
+                padding=(1, 2)
+            ))
+        if result.stderr:
+            console.print(Panel(
+                result.stderr.strip(),
+                title="[bold red]Erro[/]",
+                border_style="red",
+                box=box.ROUNDED,
+                padding=(1, 2)
+            ))
+    except Exception as e:
+        render_message("error", f"{e}")
+
+def list_skills():
+    if not CLAUDIO_SKILLS:
+        render_message("info", "Nenhuma skill encontrada em .claudio/skills/")
+        return
+    table = Table(title="Skills Disponíveis", box=box.ROUNDED, border_style="green")
+    table.add_column("Skill", style="cyan", no_wrap=True)
+    table.add_column("Arquivo", style="white")
+    for s in CLAUDIO_SKILLS:
+        table.add_row(s["name"], str(s["path"].relative_to(WORKSPACE)))
+    console.print(table)
+    render_message("info", "Use: executar skill <nome>")
+
+def execute_skill(skill_name: str, user_message: str = ""):
+    skill = None
+    skill_lower = skill_name.lower()
+    skill_stem = Path(skill_lower).stem
+    for s in CLAUDIO_SKILLS:
+        sname = s["name"].lower()
+        if sname == skill_lower or Path(sname).stem == skill_stem:
+            skill = s
+            break
+    if not skill:
+        render_message("error", f"Skill '{skill_name}' não encontrada")
+        return
+
+    render_message("info", f"Usando skill como prompt: [bold]{skill['name']}[/]")
+    full_prompt = f"""{skill['content']}
+
+{user_message or "Crie um site completo baseado nas instruções acima."}"""
+    create_project(full_prompt)
+
+def edit_file(file_path: str, instruction: str):
+    content = read_file(file_path)
+    if content is None:
+        render_message("error", f"Arquivo não encontrado: {file_path}")
+        return
+    ext = Path(file_path).suffix or ".txt"
+    ctx = make_claudio_context()
+    prompt = f"""Edite o arquivo abaixo seguindo a instrução.
+
+ARQUIVO: {file_path}
+INSTRUÇÃO: {instruction}
+
+```{ext}
+{content[:MAX_FILE_PREVIEW]}
+```
+
+REGRAS:
+- Retorne APENAS o código modificado completo
+- Não explique as mudanças
+- Não use markdown"""
+    with Status("[bold yellow]✏️ Editando arquivo...", spinner="dots"):
+        try:
+            resp = client.chat.completions.create(
+                model=MODEL,
+                messages=[
+                    {"role": "system", "content": "Você é um editor de código. Retorne APENAS o código modificado." + ctx},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.2,
+                max_tokens=MAX_TOKENS
+            )
+            new_content = resp.choices[0].message.content
+            if not new_content or is_invalid_response(new_content):
+                render_message("error", "Resposta inválida da IA")
+                return
+            new_content = re.sub(r'^```\w*\n?', '', new_content)
+            new_content = re.sub(r'\n?```$', '', new_content)
+            full_path = WORKSPACE / file_path if not Path(file_path).is_absolute() else Path(file_path)
+            render_message("info", f"Preview das alterações em {file_path}:")
+            console.print(Syntax(new_content[:2500], ext.lstrip('.'), theme="monokai", line_numbers=True))
+            if Prompt.ask("[bold yellow]Aplicar alterações?[/]", choices=["s", "n"], default="s") == "s":
+                full_path.write_text(new_content, encoding="utf-8")
+                render_message("info", f"✅ {file_path} atualizado")
+            else:
+                render_message("info", "Alterações canceladas")
+        except Exception as e:
+            render_message("error", f"Erro ao editar: {e}")
+
+def refactor_code(file_path: str):
+    content = read_file(file_path)
+    if content is None:
+        render_message("error", f"Arquivo não encontrado: {file_path}")
+        return
+    ext = Path(file_path).suffix or ".txt"
+    ctx = make_claudio_context()
+    with Status("[bold yellow]🔍 Analisando para refatorar...", spinner="dots"):
+        try:
+            analysis = client.chat.completions.create(
+                model=MODEL,
+                messages=[
+                    {"role": "system", "content": "Você é um analisador de código. Seja técnico e específico." + ctx},
+                    {"role": "user", "content": f"Analise este código para refatoração:\n\n```{ext}\n{content[:MAX_FILE_PREVIEW]}\n```\n\nIdentifique: code smells, violações de boas práticas, oportunidades de melhoria, complexidade desnecessária."}
+                ],
+                temperature=0.2,
+                max_tokens=2000
+            ).choices[0].message.content
+            render_message("assistant", f"**📋 Análise para refatoração:**\n\n{analysis}")
+            if Prompt.ask("[bold yellow]Gerar versão refatorada?[/]", choices=["s", "n"], default="s") != "s":
+                return
+            with Status("[bold yellow]🔄 Refatorando...", spinner="dots"):
+                refactored = client.chat.completions.create(
+                    model=MODEL,
+                    messages=[
+                        {"role": "system", "content": "Refatore o código. Retorne APENAS o código refatorado completo. Mantenha a mesma funcionalidade." + ctx},
+                        {"role": "user", "content": f"Refatore:\n\n```{ext}\n{content[:MAX_FILE_PREVIEW]}\n```"}
+                    ],
+                    temperature=0.2,
+                    max_tokens=MAX_TOKENS
+                ).choices[0].message.content
+            new_content = re.sub(r'^```\w*\n?', '', refactored)
+            new_content = re.sub(r'\n?```$', '', new_content)
+            full_path = WORKSPACE / file_path if not Path(file_path).is_absolute() else Path(file_path)
+            render_message("info", f"Preview da versão refatorada:")
+            console.print(Syntax(new_content[:2500], ext.lstrip('.'), theme="monokai", line_numbers=True))
+            if Prompt.ask("[bold yellow]Aplicar refatoração?[/]", choices=["s", "n"], default="s") == "s":
+                full_path.write_text(new_content, encoding="utf-8")
+                render_message("info", f"✅ {file_path} refatorado")
+            else:
+                render_message("info", "Refatoração cancelada")
+        except Exception as e:
+            render_message("error", f"Erro na refatoração: {e}")
+
+def web_search(query: str):
+    with Status(f"[bold yellow]🌐 Buscando: {query}...", spinner="dots"):
+        try:
+            url = f"https://html.duckduckgo.com/html/?q={urllib.parse.quote(query)}"
+            req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"})
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                html = resp.read().decode("utf-8", errors="ignore")
+            results = []
+            for m in re.finditer(r'<a[^>]*class="result__a"[^>]*>(.*?)</a>.*?class="result__snippet"[^>]*>(.*?)</a>', html, re.DOTALL):
+                title = re.sub(r'<[^>]+>', '', m.group(1)).strip()
+                snippet = re.sub(r'<[^>]+>', '', m.group(2)).strip()
+                results.append(f"• {title}\n  {snippet}")
+            text = "\n\n".join(results[:10]) if results else "Nenhum resultado encontrado."
+            render_message("assistant", f"**🌐 Resultados para:** {query}\n\n{text}")
+        except Exception as e:
+            render_message("info", f"Não foi possível buscar online. Usando conhecimento da IA...")
+            normal_chat(f"Pesquise e responda sobre: {query}")
+
+def fetch_url(url: str):
+    with Status(f"[bold yellow]🌐 Acessando: {url}...", spinner="dots"):
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                content = resp.read().decode("utf-8", errors="ignore")
+            text = re.sub(r'<[^>]+>', ' ', content)
+            text = re.sub(r'\s+', ' ', text).strip()[:8000]
+            render_message("assistant", f"**📄 Conteúdo de:** {url}\n\n{text}")
+        except Exception as e:
+            render_message("error", f"Erro ao acessar URL: {e}")
+
+def git_command(args: str):
+    with Status(f"[bold yellow]🔧 git {args}...", spinner="dots"):
+        try:
+            result = subprocess.run(f"git {args}", shell=True, capture_output=True, text=True, cwd=WORKSPACE)
+            if result.returncode != 0:
+                render_message("error", result.stderr.strip() or f"git falhou (código {result.returncode})")
+                return
+            output = result.stdout.strip() or result.stderr.strip() or "(sem output)"
+            render_message("code", output[:5000])
+        except Exception as e:
+            render_message("error", f"Erro git: {e}")
+
+def reconfigurar():
+    global API_KEY, MODEL, client
+    console.print(Panel(
+        "[bold]Reconfigurando claudio...[/]",
+        title="[bold cyan]⚙️ Configuração[/]",
+        border_style="cyan",
+        box=box.ROUNDED
+    ))
+
+    old_key = API_KEY
+    masked = old_key[:8] + "..." + old_key[-4:] if len(old_key) > 12 else "***"
+    console.print(f"Chave atual: [green]{masked}[/]")
+    if Prompt.ask("[bold yellow]Alterar chave?[/]", choices=["s", "n"], default="n") == "s":
+        new_key = Prompt.ask("[bold yellow]🔑 Nova API Key[/]", password=True)
+        while not new_key or not new_key.startswith("sk-"):
+            console.print("[red]❌ Chave inválida. Deve começar com 'sk-'[/]")
+            new_key = Prompt.ask("[bold yellow]🔑 Nova API Key[/]", password=True)
+        API_KEY = new_key
+        save_config({"api_key": new_key})
+        client = OpenAI(api_key=API_KEY, timeout=120)
+        console.print("[green]✅ Chave atualizada[/]")
+
+    console.print(f"\nModelo atual: [green]{MODEL}[/]")
+    if Prompt.ask("[bold yellow]Alterar modelo?[/]", choices=["s", "n"], default="n") == "s":
+        for i, m in enumerate(AVAILABLE_MODELS, 1):
+            console.print(f"  [cyan]{i}.[/] {m}")
+        model_idx = Prompt.ask("[bold yellow]🎯 Escolha o modelo[/]", choices=[str(i) for i in range(1, len(AVAILABLE_MODELS)+1)], default="1")
+        MODEL = AVAILABLE_MODELS[int(model_idx) - 1]
+        save_config({"model": MODEL})
+        console.print(f"[green]✅ Modelo alterado para: {MODEL}[/]")
+
+    render_message("info", "⚙️ Configuração concluída")
+
+def switch_model(model_name: str):
+    global MODEL
+    if not model_name:
+        render_message("info", f"Modelo atual: {MODEL}\nDisponíveis: {', '.join(AVAILABLE_MODELS)}")
+        return
+    lower = model_name.lower()
+    matches = [m for m in AVAILABLE_MODELS if lower in m.lower()]
+    if len(matches) == 0:
+        render_message("error", f"Modelo '{model_name}' não encontrado. Disponíveis: {', '.join(AVAILABLE_MODELS)}")
+    elif len(matches) == 1:
+        MODEL = matches[0]
+        save_config({"model": MODEL})
+        render_message("info", f"🧠 Modelo alterado para: {MODEL}")
+    else:
+        render_message("info", f"Múltiplos correspondem: {', '.join(matches)}")
+
+def auto_install_deps():
+    with Status("[bold yellow]🔍 Examinando dependências...", spinner="dots"):
+        try:
+            imports = set()
+            for root, dirs, files in os.walk(WORKSPACE):
+                dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
+                for f in files:
+                    if f.endswith(".py"):
+                        content = Path(root, f).read_text(encoding="utf-8", errors="ignore")
+                        for m in re.finditer(r'^(?:import|from)\s+(\w+)', content, re.MULTILINE):
+                            imports.add(m.group(1))
+            stdlib = {"os", "sys", "json", "re", "subprocess", "io", "pathlib", "datetime",
+                      "math", "random", "collections", "functools", "itertools", "typing",
+                      "abc", "copy", "enum", "hashlib", "base64", "textwrap", "uuid",
+                      "urllib", "http", "socket", "threading", "multiprocessing", "xml",
+                      "csv", "sqlite3", "html", "inspect", "logging", "pprint", "queue",
+                      "shutil", "string", "struct", "tempfile", "time", "traceback",
+                      "weakref", "zipfile"}
+            third_party = {i for i in imports if i not in stdlib and not i.startswith("_")}
+            if not third_party:
+                render_message("info", "Nenhuma dependência externa detectada")
+                return
+            render_message("info", f"Dependências detectadas: {', '.join(sorted(third_party))}")
+            if Prompt.ask("[bold yellow]Instalar todas?[/]", choices=["s", "n"], default="s") != "s":
+                return
+            for pkg in sorted(third_party):
+                render_message("info", f"📦 Instalando {pkg}...")
+                r = subprocess.run(f"pip install {pkg}", shell=True, capture_output=True, text=True)
+                if r.returncode == 0:
+                    render_message("info", f"✅ {pkg} instalado")
+                else:
+                    render_message("error", f"❌ {pkg}: {r.stderr.strip()[:200]}")
+        except Exception as e:
+            render_message("error", f"Erro: {e}")
+
+def autonomous_mode(task: str):
+    render_message("info", f"🎯 Missão autônoma: {task}")
+    ctx = make_claudio_context()
+    structure = get_project_structure()[:2000]
+    with Status("[bold yellow]🧠 Planejando missão...", spinner="dots"):
+        try:
+            plan_resp = client.chat.completions.create(
+                model=MODEL,
+                response_format={"type": "json_object"},
+                messages=[
+                    {"role": "system", "content": "Você é um planejador de missões. Gere JSON com planos detalhados." + ctx},
+                    {"role": "user", "content": f"""Crie um plano para executar esta missão:
+
+MISSÃO: {task}
+
+Workspace:
+{structure}
+
+Retorne JSON:
+{{"passos": [
+  {{"tipo": "ler|escrever|executar|analisar|perguntar", "alvo": "...", "descricao": "..."}}
+]}}"""}
+                ],
+                temperature=0.2,
+                max_tokens=2000
+            )
+            plan_data = json.loads(plan_resp.choices[0].message.content)
+            passos = plan_data.get("passos", [])
+            if not passos:
+                render_message("error", "Não foi possível gerar um plano")
+                return
+            render_message("info", f"📋 Plano: {len(passos)} passos")
+            results = []
+            for i, passo in enumerate(passos, 1):
+                tipo = passo.get("tipo", "")
+                alvo = passo.get("alvo", "")
+                desc = passo.get("descricao", "")
+                render_message("info", f"[bold][{i}/{len(passos)}][/] {desc}")
+                if tipo == "ler":
+                    c = read_file(alvo)
+                    results.append(f"// {alvo}\n{c[:2000] if c else 'não encontrado'}" if c else f"// {alvo}: não encontrado")
+                elif tipo == "escrever":
+                    gen = client.chat.completions.create(
+                        model=MODEL,
+                        messages=[
+                            {"role": "system", "content": f"Gere código para {alvo} baseado na missão: {task}"},
+                            {"role": "user", "content": f"Contexto:\n{chr(10).join(results[-3:])}\n\nGere o conteúdo completo para {alvo}"}
+                        ],
+                        temperature=0.2,
+                        max_tokens=4000
+                    ).choices[0].message.content
+                    write_file(alvo, gen)
+                    results.append(f"// {alvo}: criado")
+                elif tipo == "executar":
+                    r = subprocess.run(alvo, shell=True, capture_output=True, text=True, cwd=WORKSPACE)
+                    out = (r.stdout or r.stderr or "")[-1000:]
+                    results.append(f"$ {alvo}\n{out}")
+                    render_message("code", out[:2000])
+                elif tipo == "analisar":
+                    c = read_file(alvo)
+                    if c:
+                        a = client.chat.completions.create(
+                            model=MODEL,
+                            messages=[{"role": "system", "content": "Analise o código objetivamente."}, {"role": "user", "content": f"```\n{c[:3000]}\n```"}],
+                            temperature=0.2, max_tokens=1000
+                        ).choices[0].message.content
+                        results.append(f"// análise {alvo}:\n{a}")
+                        render_message("assistant", a[:2000])
+                elif tipo == "perguntar":
+                    a = client.chat.completions.create(
+                        model=MODEL,
+                        messages=[{"role": "system", "content": "Você é um assistente de programação." + ctx}, {"role": "user", "content": f"Missão: {task}\n\n{alvo}"}],
+                        temperature=0.3, max_tokens=1000
+                    ).choices[0].message.content
+                    results.append(f"// consulta:\n{a}")
+            render_message("info", "🏁 Missão concluída!")
+            summary = client.chat.completions.create(
+                model=MODEL,
+                messages=[
+                    {"role": "system", "content": "Resuma em português o resultado da missão."},
+                    {"role": "user", "content": f"MISSÃO: {task}\n\nRESULTADOS:\n{chr(10).join(results[-8:])}"}
+                ],
+                temperature=0.3, max_tokens=1000
+            ).choices[0].message.content
+            render_message("assistant", f"**📊 Resumo da Missão**\n\n{summary}")
+        except json.JSONDecodeError:
+            render_message("error", "Erro ao interpretar plano. Executando como chat...")
+            normal_chat(f"Crie um plano e execute a seguinte missão passo a passo: {task}")
+        except Exception as e:
+            render_message("error", f"Erro na missão: {e}")
+
+def show_help():
+    help_table = Table(title="Comandos Disponíveis", box=box.ROUNDED, border_style="cyan")
+    help_table.add_column("Comando", style="cyan", no_wrap=True)
+    help_table.add_column("Descrição", style="white")
+    help_table.add_row("analisar projeto", "Analisa todo o projeto")
+    help_table.add_row("analisar <arquivo/pasta>", "Analisa um alvo específico")
+    help_table.add_row("listar/ls <caminho>", "Lista arquivos de uma pasta")
+    help_table.add_row("ler <arquivo>", "Mostra o conteúdo de um arquivo")
+    help_table.add_row("editar <arquivo> <desc>", "Edita um arquivo via IA")
+    help_table.add_row("refatorar <arquivo>", "Refatora código automaticamente")
+    help_table.add_row("debug <arquivo> <erro>", "Debuga um arquivo com erro")
+    help_table.add_row("executar <comando>", "Executa comando no terminal")
+    help_table.add_row("git <args>", "Executa comandos git")
+    help_table.add_row("buscar <query>", "Busca na internet")
+    help_table.add_row("site <url>", "Acessa conteúdo de uma URL")
+    help_table.add_row("executar skill <nome>", "Executa uma skill")
+    help_table.add_row("skills", "Lista skills disponíveis")
+    help_table.add_row("crie/criar/gere/faça <desc>", "Gera um projeto completo")
+    help_table.add_row("autonomo/missao <desc>", "Modo autônomo multi-passo")
+    help_table.add_row("modelo <nome>", "Troca o modelo GPT")
+    help_table.add_row("config", "Altera chave API e modelo")
+    help_table.add_row("instalar/deps", "Auto-instala dependências")
+    help_table.add_row("salvar", "Salva o histórico da sessão")
+    help_table.add_row("carregar", "Carrega a última sessão")
+    help_table.add_row("/exit", "Sai do programa")
+    help_table.add_row("/help", "Mostra esta ajuda")
+    help_table.add_row("qualquer outra coisa", "Chat normal com a IA")
+    console.print(help_table)
+
+def show_header():
+    header_lines = [
+        "[bold cyan]🤖 claudio AUTÔNOMO[/]",
+        f"[white]📁[/] [yellow]{WORKSPACE}[/]",
+        f"[white]🧠[/] [green]{MODEL}[/]"
+    ]
+    loaded = []
+    if CLAUDIO_MD:
+        loaded.append("claudio.md")
+    if CLAUDIO_SKILLS:
+        loaded.append(f"skills/{len(CLAUDIO_SKILLS)}")
+    if CLAUDIO_RULES:
+        n = sum(1 for _ in (WORKSPACE / ".claudio" / "RULES").iterdir()) if (WORKSPACE / ".claudio" / "RULES").exists() else 0
+        loaded.append(f"RULES/{n}")
+    if HISTORY_FILE.exists():
+        loaded.append("sessão")
+    if loaded:
+        header_lines.append(f"[white]📄[/] [green]✓ {', '.join(loaded)}[/]")
+    header = Panel(
+        "\n".join(header_lines),
+        box=box.ROUNDED,
+        border_style="cyan",
+        padding=(1, 2)
+    )
+    console.print(header)
+
+def main():
+    console.clear()
+    show_header()
+
+    while True:
+        try:
+            user = Prompt.ask(
+                "\n[bold cyan]💻 agent[/]"
+            )
+
+            if not user:
+                continue
+
+            lower = user.lower().strip()
+
+            if lower == "/exit":
+                session_save()
+                console.print("[yellow]👋 Encerrando...[/]")
+                break
+
+            if lower == "/help":
+                show_help()
+                continue
+
+            if lower in ["/skills", "skills", "/skill"]:
+                list_skills()
+                continue
+
+            ANALISE_KEYWORDS = ["analisar", "analise", "analisa", "analyze", "analyse"]
+            if any(lower.startswith(kw) for kw in ANALISE_KEYWORDS) and any(
+                word in lower for word in ["projeto", "proyect", "project"]
+            ):
+                analyze_project()
+                continue
+
+            elif any(lower.startswith(kw) for kw in ANALISE_KEYWORDS):
+                target = ""
+                for word in ["pasta ", "diretorio ", "diretório ", "arquivo ", "folder ", "file "]:
+                    if word in lower:
+                        idx = lower.index(word) + len(word)
+                        target = user[idx:].strip()
+                        break
+                if not target:
+                    parts = user.split(maxsplit=1)
+                    if len(parts) >= 2:
+                        target = parts[1].strip()
+                        for prefix in ["a ", "o ", "as ", "os ", "de ", "da ", "do ", "das ", "dos "]:
+                            if target.lower().startswith(prefix):
+                                target = target[len(prefix):].strip()
+                if not target:
+                    render_message("error", "Informe o arquivo ou pasta")
+                    continue
+                p_target = Path(target)
+                full_path = p_target if p_target.is_absolute() else WORKSPACE / target
+                render_message("info", f"[bold]> Alvo:[/] {full_path}")
+                if full_path.exists() and full_path.is_dir():
+                    analyze_folder(str(full_path))
+                else:
+                    analyze_code(str(full_path))
+                continue
+
+            elif lower.startswith("listar") or lower in ["ls", "dir", "tree"]:
+                parts = user.split(maxsplit=1)
+                path = parts[1] if len(parts) > 1 else "."
+                list_directory(path)
+                continue
+
+            elif lower.startswith("ler "):
+                parts = user.split(maxsplit=1)
+                if len(parts) < 2:
+                    render_message("error", "Informe o arquivo")
+                    continue
+                read_file_content(parts[1])
+                continue
+
+            elif lower.startswith("editar ") or lower.startswith("modificar "):
+                prefix_len = len("editar ") if lower.startswith("editar ") else len("modificar ")
+                rest = user[prefix_len:].strip()
+                first_word_end = rest.find(" ")
+                if first_word_end == -1:
+                    render_message("error", "Use: editar <arquivo> <instrução>")
+                    continue
+                fpath = rest[:first_word_end].strip()
+                instr = rest[first_word_end:].strip()
+                edit_file(fpath, instr)
+                continue
+
+            elif lower.startswith("refatorar"):
+                parts = user.split(maxsplit=1)
+                if len(parts) < 2:
+                    render_message("error", "Use: refatorar <arquivo>")
+                    continue
+                refactor_code(parts[1])
+                continue
+
+            elif lower.startswith("debug"):
+                parts = user.split()
+                if len(parts) < 2:
+                    render_message("error", "Informe o arquivo")
+                    continue
+                file_path = parts[1]
+                error = " ".join(parts[2:])
+                debug_code(file_path, error)
+                continue
+
+            elif lower.startswith("executar"):
+                rest = user[len("executar"):].strip()
+                skill_target = None
+                stem = Path(rest).stem.lower()
+                for s in CLAUDIO_SKILLS:
+                    if s["name"].lower() == rest.lower() or Path(s["name"]).stem.lower() == stem:
+                        skill_target = s["name"]
+                        break
+                if not skill_target and (rest.lower().startswith("skill") or rest.lower().startswith("a skill")):
+                    sr = rest[5:] if rest.lower().startswith("skill") else rest[7:]
+                    sr = sr.strip()
+                    for s in CLAUDIO_SKILLS:
+                        if s["name"].lower() == sr.lower() or Path(s["name"]).stem.lower() == Path(sr).stem.lower():
+                            skill_target = s["name"]
+                            break
+                if skill_target:
+                    execute_skill(skill_target)
+                else:
+                    run_terminal(rest)
+                continue
+
+            elif lower.startswith("git "):
+                git_command(user[4:].strip())
+                continue
+
+            elif lower.startswith("buscar ") or lower.startswith("pesquisar "):
+                prefix = len("buscar ") if lower.startswith("buscar ") else len("pesquisar ")
+                web_search(user[prefix:].strip())
+                continue
+
+            elif lower.startswith("site ") or lower.startswith("acessar "):
+                prefix = len("site ") if lower.startswith("site ") else len("acessar ")
+                fetch_url(user[prefix:].strip())
+                continue
+
+            elif lower.startswith("skill "):
+                sname = user[6:].strip()
+                if sname:
+                    execute_skill(sname)
+                else:
+                    list_skills()
+                continue
+
+            elif lower.startswith("modelo"):
+                parts = user.split(maxsplit=1)
+                model_name = parts[1] if len(parts) > 1 else ""
+                switch_model(model_name)
+                continue
+
+            elif lower in ["config", "configurar", "reconfigurar", "setup"]:
+                reconfigurar()
+                continue
+
+            elif lower in ["salvar", "salvar sessão"]:
+                session_save()
+                render_message("info", "💾 Sessão salva")
+                continue
+
+            elif lower in ["carregar", "carregar sessão", "restaurar"]:
+                session_load()
+                continue
+
+            elif lower in ["instalar", "deps", "instalar deps"]:
+                auto_install_deps()
+                continue
+
+            elif lower.startswith("autonomo") or lower.startswith("missao") or lower.startswith("missão"):
+                prefix = next(len(p) for p in ["autonomo ", "missao ", "missão "] if lower.startswith(p))
+                task = user[prefix:].strip()
+                if not task:
+                    render_message("error", "Descreva a missão. Ex: autonomo crie um servidor web")
+                    continue
+                autonomous_mode(task)
+                continue
+
+            elif any(kw in lower for kw in ["crie", "criar", "gere", "faça", "desenvolva"]):
+                create_project(user)
+                continue
+
+            else:
+                normal_chat(user)
+
+        except KeyboardInterrupt:
+            console.print("\n[yellow]👋 Encerrando...[/]")
+            break
+
+        except Exception as e:
+            render_message("error", f"{e}")
+
+if __name__ == "__main__":
+    main()
+```
+
+## Observações
+
+- API Key: lida primeiro de `os.getenv("API_KEY")`, depois do `.env`
+- `.claudio/` contém skills e RULES carregados automaticamente no contexto
+- `.claudio_history.json` é gerado automaticamente ao salvar sessão
+- O `__pycache__/` é gerado automaticamente pelo Python
+- `.env` contém a chave da API — **nunca compartilhe ou comite este arquivo**