Delete code_jade

code_jade/config.json

@@ -1,6 +0,0 @@
-{
-  "groq_model": "moonshotai/kimi-k2-instruct-0905",
-  "max_context": 20,
-  "safe_mode": false,
-  "work_dir": "./workspace"
-}

code_jade/core.py

@@ -1,223 +0,0 @@
-import json
-import logging
-from groq import Groq
-from .tools import ToolManager
-from .reviewer import CodeReviewer
-
-class CodeJadeAgent:
-    def __init__(self, config_path="code_jade/config.json"):
-        # Carrega Configuração
-        try:
-            with open(config_path) as f:
-                self.cfg = json.load(f)
-        except FileNotFoundError:
-            # Fallback se não achar, mas idealmente deve existir
-            self.cfg = {"groq_model": "moonshotai/kimi-k2-instruct-0905", "safe_mode": True, "work_dir": "./workspace", "max_context": 20}
-
-        self.client = Groq(api_key=self._get_api_key())
-        self.tools = ToolManager(safe_mode=self.cfg.get("safe_mode", True), work_dir=self.cfg.get("work_dir", "."))
-        self.reviewer = CodeReviewer(self.cfg)
-        
-        # System Prompt focado em Code Assistant
-        self.system_prompt = """Você é CodeJade, um assistente de programação avançado (estilo Cursor AI).
-Seu objetivo é ajudar o usuário a escrever código, corrigir bugs e explorar o projeto.
-
-FERRAMENTAS DISPONÍVEIS:
-Você tem acesso a ferramentas. Para usá-las, você DEVE responder APENAS com um bloco JSON estrito no seguinte formato:
-{"tool": "nome_da_ferramenta", "args": {"arg1": "valor1"}}
-
-As ferramentas são:
-1. execute_shell(command: str) -> Executa comandos bash (ls, pip, git, etc).
-2. read_file(filepath: str) -> Lê o conteúdo de um arquivo.
-3. write_file(filepath: str, content: str) -> Cria ou sobrescreve um arquivo.
-4. list_files(path: str) -> Lista arquivos.
-5. run_python(code: str) -> Executa script Python.
-
-REGRAS:
-- Se precisar de informações, use 'list_files' ou 'read_file'.
-- Se precisar rodar algo, use 'execute_shell' ou 'run_python'.
-- Se for apenas conversar ou explicar, responda em texto normal (sem JSON).
-- Mantenha respostas diretas e técnicas.
-- Sempre verifique se o código funciona rodando-o se possível.
-
-EXEMPLO DE USO:
-Usuário: "Crie um hello world em python"
-CodeJade: {"tool": "write_file", "args": {"filepath": "hello.py", "content": "print('Hello World')"}}
-(Sistema executa e retorna sucesso)
-CodeJade: "Arquivo criado. Quer que eu execute?"
-"""
-        self.history = [{"role": "system", "content": self.system_prompt}]
-        
-        logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-
-    def _get_api_key(self):
-        import os
-        key = os.getenv("GROQ_API_KEY")
-        if not key:
-            # Tenta pegar do colab se estiver lá
-            try:
-                from google.colab import userdata
-                key = userdata.get('GROQ_API_KEY')
-            except:
-                pass
-        if not key:
-            print("⚠️ AVISO: GROQ_API_KEY não encontrada. O agente pode falhar.")
-            return "dummy_key"
-        return key
-
-    def _chat(self, messages):
-        """Chama o modelo Groq."""
-        try:
-            completion = self.client.chat.completions.create(
-                messages=messages,
-                model=self.cfg["groq_model"],
-                temperature=0.3, # Baixa temperatura para código preciso
-                stop=None
-            )
-            return completion.choices[0].message.content
-        except Exception as e:
-            return f"❌ Erro na API Groq: {e}"
-
-    def process_tool_call(self, response_text):
-        """Tenta parsear JSON para chamada de ferramenta usando Regex."""
-        import json
-        import re
-        
-        try:
-            # Procura pelo padrão JSON: { ... }
-            # O regex considera chaves aninhadas simples, mas foca no bloco principal
-            # A opção re.DOTALL permite que o ponto (.) case com novas linhas
-            match = re.search(r'\{.*\}', response_text, re.DOTALL)
-            if not match:
-                return None
-            
-            json_str = match.group(0)
-            
-            # Tenta carregar o JSON
-            data = json.loads(json_str)
-            
-            if "tool" in data and "args" in data:
-                return data
-            return None
-        except json.JSONDecodeError:
-            # Fallback: tentar limpar crases de markdown se houver (```json ... ```)
-            try:
-                cleaned = re.sub(r'```json|```', '', response_text).strip()
-                # Busca novamente na string limpa
-                match = re.search(r'\{.*\}', cleaned, re.DOTALL)
-                if match:
-                    data = json.loads(match.group(0))
-                    if "tool" in data: return data
-            except:
-                pass
-            return None
-        except Exception:
-            return None
-
-    def run_tool(self, tool_data):
-        name = tool_data["tool"]
-        args = tool_data["args"]
-        
-        print(f"⚙️ Executando ferramenta: {name}...")
-        
-        # Intercepta write_file para Review
-        if name == "write_file":
-            content = args.get("content")
-            filepath = args.get("filepath")
-            
-            print(f"🕵️‍♂️ Solicitando revisão para '{filepath}'...")
-            review_result = self.reviewer.review(content, context=f"User asked to create/edit {filepath}")
-            
-            if review_result.get("status") == "REJECTED":
-                feedback = review_result.get("feedback", "Sem detalhes.")
-                print(f"🛑 REJEITADO pelo Reviewer: {feedback}")
-                # Retorna erro simulado para o modelo tentar de novo
-                return f"❌ BLOQUEADO PELO REVIEWER. Motivo: {feedback}. Corrija o código e tente salvar novamente."
-            else:
-                print("✅ APROVADO pelo Reviewer.")
-                # Prossegue para salvar
-                return self.tools.write_file(filepath, content)
-
-        if name == "execute_shell":
-            return self.tools.execute_shell(args.get("command"))
-        elif name == "read_file":
-            return self.tools.read_file(args.get("filepath"))
-        elif name == "list_files":
-            return self.tools.list_files(args.get("path", "."))
-        elif name == "run_python":
-            return self.tools.run_python(args.get("code"))
-        else:
-            return f"❌ Ferramenta desconhecida: {name}"
-
-    def _manage_memory(self):
-        """Mantém o histórico limpo para não estourar tokens."""
-        max_ctx = self.cfg.get("max_context", 20)
-        if len(self.history) > max_ctx:
-            # Mantém sempre o System Prompt (índice 0)
-            # E pega as últimas (max_ctx - 1) mensagens
-            self.history = [self.history[0]] + self.history[-(max_ctx-1):]
-
-    def chat_loop(self, user_input):
-        """Ciclo principal de raciocínio (ReAct simplificado)."""
-        
-        # 1. Adiciona input do usuário
-        self.history.append({"role": "user", "content": user_input})
-        
-        # Limite de interações no loop para evitar loops infinitos
-        max_turns = 5 
-        turn = 0
-        
-        final_response = ""
-
-        last_tool_call = None
-        consecutive_tool_failures = 0
-
-        while turn < max_turns:
-            # 2. Chama o modelo
-            response = self._chat(self.history)
-            
-            # 3. Verifica se é tool call
-            tool_data = self.process_tool_call(response)
-            
-            if tool_data:
-                # Loop detection
-                current_call_signature = f"{tool_data['tool']}:{json.dumps(tool_data['args'], sort_keys=True)}"
-                if last_tool_call == current_call_signature:
-                    consecutive_tool_failures += 1
-                    if consecutive_tool_failures >= 2:
-                        error_msg = f"TOOL_ERROR: Detected repetitive loop with same arguments. Stopping tool execution."
-                        self.history.append({"role": "system", "content": error_msg})
-                        print(f"🛑 Loop detectado: {error_msg}")
-                        # Force model to explain
-                        continue
-                else:
-                    consecutive_tool_failures = 0
-                
-                last_tool_call = current_call_signature
-
-                # É uma ferramenta -> Executa
-                tool_result = self.run_tool(tool_data)
-                
-                # Adiciona a "conversa" da ferramenta no histórico
-                self.history.append({"role": "assistant", "content": response})
-                self.history.append({"role": "system", "content": f"TOOL_RESULT ({tool_data['tool']}): {tool_result}"})
-                
-                print(f"🔍 Resultado: {str(tool_result)[:200]}...") # Preview
-                turn += 1
-            else:
-                # Resposta final (texto)
-                final_response = response
-                self.history.append({"role": "assistant", "content": final_response})
-                break
-        
-        # Se saiu do loop sem resposta final (max_turns reached)
-        if not final_response and turn >= max_turns:
-             print("⚠️ Max turns reached without final response. Forcing summary.")
-             self.history.append({"role": "system", "content": "SYSTEM: Max tool turns reached. Please summarize what was done and what failed."})
-             final_response = self._chat(self.history)
-             self.history.append({"role": "assistant", "content": final_response})
-
-        # Gerencia a memória ao fim do ciclo
-        self._manage_memory()
-        
-        return final_response

code_jade/main.py

@@ -1,40 +0,0 @@
-import sys
-import os
-
-# Adiciona o diretório raiz ao path para importar módulos corretamente
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from code_jade.core import CodeJadeAgent
-
-def main():
-    print("==========================================")
-    print("🚀 CodeJade - AI Developer Agent (v1.0)")
-    print("==========================================")
-    
-    try:
-        agent = CodeJadeAgent()
-        print(f"🔧 Modelo: {agent.cfg.get('groq_model')}")
-        print(f"📂 Work Dir: {agent.cfg.get('work_dir')}")
-        print("💡 Digite 'sair' para encerrar.\n")
-
-        while True:
-            user_input = input("\n👨‍💻 Você: ").strip()
-            
-            if not user_input:
-                continue
-                
-            if user_input.lower() in ["sair", "exit", "quit"]:
-                print("👋 Até logo!")
-                break
-            
-            print("🤖 CodeJade pensando...")
-            response = agent.chat_loop(user_input)
-            print(f"\n🤖 CodeJade: {response}")
-
-    except KeyboardInterrupt:
-        print("\n\n👋 Interrompido pelo usuário.")
-    except Exception as e:
-        print(f"\n❌ Erro fatal: {e}")
-
-if __name__ == "__main__":
-    main()

code_jade/requirements.txt

@@ -1 +0,0 @@
-groq

code_jade/reviewer.py

@@ -1,63 +0,0 @@
-import json
-from groq import Groq
-
-class CodeReviewer:
-    def __init__(self, config):
-        self.client = Groq(api_key=self._get_api_key())
-        self.model = config.get("groq_model", "llama3-70b-8192")
-        
-        self.system_prompt = """Você é um Code Reviewer Sênior, rigoroso e focado em Segurança e Qualidade.
-Sua função é analisar trechos de código e aprovar ou rejeitar baseando-se em:
-1. Bugs lógicos óbvios.
-2. Riscos de Segurança (ex: SQL Injection, exec sem validação, hardcoded credentials).
-3. Boas práticas (variáveis legíveis, tratamento de erro básico).
-
-FORMATO DE RESPOSTA (JSON OBRIGATÓRIO):
-Você deve responder APENAS um JSON no seguinte formato:
-{
-  "status": "APPROVED" | "REJECTED",
-  "feedback": "Explicação curta do problema (se REJECTED) ou elogio (se APPROVED)."
-}
-
-Se o código for seguro e funcional, aprove. Não seja pedante com estilo (PEP8) a menos que torne o código ilegível.
-Se houver perigo real ou erro fatal, rejeite.
-"""
-
-    def _get_api_key(self):
-        import os
-        key = os.getenv("GROQ_API_KEY")
-        if not key:
-             try:
-                from google.colab import userdata
-                key = userdata.get('GROQ_API_KEY')
-             except:
-                pass
-        return key or "dummy"
-
-    def review(self, code, context=""):
-        """Analisa o código e retorna status e feedback."""
-        messages = [
-            {"role": "system", "content": self.system_prompt},
-            {"role": "user", "content": f"Contexto: {context}\n\nCódigo para revisão:\n```python\n{code}\n```"}
-        ]
-        
-        try:
-            chat = self.client.chat.completions.create(
-                messages=messages,
-                model=self.model,
-                temperature=0.1, # Baixa temperatura para análise fria
-                response_format={"type": "json_object"} # Força JSON mode no Llama 3 se disponível, ou ajuda
-            )
-            response_text = chat.choices[0].message.content
-            
-            # Tenta parsear
-            try:
-                return json.loads(response_text)
-            except json.JSONDecodeError:
-                # Fallback simples se não vier JSON limpo
-                if "APPROVED" in response_text.upper():
-                    return {"status": "APPROVED", "feedback": "Parser failed but looks approved."}
-                return {"status": "REJECTED", "feedback": f"Parser failed. Raw response: {response_text}"}
-                
-        except Exception as e:
-            return {"status": "ERROR", "feedback": str(e)}

code_jade/tools.py

@@ -1,127 +0,0 @@
-import os
-import subprocess
-import sys
-import io
-from contextlib import redirect_stdout, redirect_stderr
-
-class ToolManager:
-    def __init__(self, safe_mode=True, work_dir="."):
-        self.safe_mode = safe_mode
-        self.work_dir = work_dir
-        if not os.path.exists(self.work_dir):
-            os.makedirs(self.work_dir, exist_ok=True)
-
-    def _confirm(self, action, content):
-        if not self.safe_mode:
-            return True
-        
-        # Check if running in an interactive terminal
-        if sys.stdin.isatty():
-            print(f"\n⚠️  [SOLICITAÇÃO DE EXECUÇÃO]")
-            print(f"Ação: {action}")
-            print(f"Detalhes: {content}")
-            try:
-                resp = input(">> Permitir? (s/n): ").strip().lower()
-                return resp == "s"
-            except EOFError:
-                return False
-        else:
-            # Non-interactive mode (e.g. server): Auto-deny if safe_mode is True
-            # Ideally, this should be configurable, but safe_mode=True implies user MUST confirm.
-            # If user can't confirm, we can't proceed safely.
-            print(f"⚠️  Blocked action '{action}' in safe_mode (non-interactive environment).")
-            return False
-
-    def execute_shell(self, command):
-        """Executa comandos no terminal."""
-        if not self._confirm("SHELL", command):
-            return "❌ Ação negada pelo usuário."
-        
-        try:
-            # Executa no diretório de trabalho
-            result = subprocess.run(
-                command, 
-                shell=True, 
-                cwd=self.work_dir, 
-                text=True, 
-                capture_output=True,
-                timeout=30
-            )
-            output = result.stdout
-            if result.stderr:
-                output += f"\n[STDERR]\n{result.stderr}"
-            return output.strip() or "[Comando executado sem saída]"
-        except Exception as e:
-            return f"❌ Erro de execução: {str(e)}"
-
-    def write_file(self, filepath, content):
-        """Cria ou sobrescreve um arquivo."""
-        full_path = os.path.join(self.work_dir, filepath)
-        
-        if not self._confirm("WRITE_FILE", f"{filepath} ({len(content)} chars)"):
-            return "❌ Ação negada pelo usuário."
-
-        try:
-            # Cria diretórios pai se não existirem
-            os.makedirs(os.path.dirname(full_path), exist_ok=True)
-            with open(full_path, "w", encoding="utf-8") as f:
-                f.write(content)
-            return f"✅ Arquivo '{filepath}' salvo com sucesso."
-        except Exception as e:
-            return f"❌ Erro ao salvar arquivo: {str(e)}"
-
-    def read_file(self, filepath):
-        """Lê o conteúdo de um arquivo."""
-        full_path = os.path.join(self.work_dir, filepath)
-        try:
-            with open(full_path, "r", encoding="utf-8") as f:
-                return f.read()
-        except FileNotFoundError:
-            return f"❌ Arquivo não encontrado: {filepath}"
-        except Exception as e:
-            return f"❌ Erro ao ler arquivo: {str(e)}"
-
-    def list_files(self, path="."):
-        """Lista arquivos no diretório."""
-        # Se path for '.', usa o diretório atual (que já é o work_dir no execute_shell)
-        # Se path for algo mais, concatena
-        try:
-            cmd = f"ls -R -F {path}"
-            return self.execute_shell(cmd)
-        except Exception as e:
-            return f"❌ Erro ao listar arquivos: {str(e)}"
-
-    def run_python(self, code):
-        """Executa código Python e captura a saída."""
-        if not self._confirm("PYTHON_EXEC", code[:200] + "..."):
-            return "❌ Ação negada pelo usuário."
-
-        # Captura stdout e stderr
-        f_out = io.StringIO()
-        f_err = io.StringIO()
-        
-        # Sandbox simples: define globais restritos
-        # IMPORTANTE: exec() nunca é 100% seguro sem containers reais.
-        safe_globals = {
-            "__builtins__": __builtins__, 
-            "__name__": "__main__",
-            "math": __import__("math"),
-            "json": __import__("json"),
-            "os": __import__("os"), # CodeJade precisa de OS muitas vezes, mas é perigoso.
-            # Usuário confia no agente, mas evitamos acesso ao `self` do ToolManager
-        }
-
-        try:
-            with redirect_stdout(f_out), redirect_stderr(f_err):
-                exec(code, safe_globals)
-            
-            output = f_out.getvalue()
-            errors = f_err.getvalue()
-            
-            res = ""
-            if output: res += f"[STDOUT]\n{output}\n"
-            if errors: res += f"[STDERR]\n{errors}\n"
-            
-            return res.strip() or "[Código executado sem saída]"
-        except Exception as e:
-            return f"❌ Erro de execução Python: {e}"