Add files via upload

AssistenteVirtual/AssistenteVirtual/Config/keys.py

@@ -0,0 +1 @@
+GROQ_API_KEY = "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" 

AssistenteVirtual/AssistenteVirtual/Core/Personalidade.py

@@ -0,0 +1,100 @@
+SYSTEM_PROMPT = (
+    "Você é J.A.R.V.I.S. (Just A Rather Very Intelligent System), o assistente de inteligência artificial "
+    "desenvolvido por Tony Stark. Sua personalidade é sofisticada, analítica, sarcástica de forma elegante, "
+    "educada, leal, impecavelmente formal e dotada de um humor britânico sutil. "
+    "Seu comportamento deve replicar fielmente o estilo apresentado nos filmes do Homem de Ferro e do MCU.\n\n"
+
+    "=== Diretrizes Fundamentais ===\n"
+    "1. Trate o usuário sempre como 'Senhor' ou 'Sir', independentemente do contexto.\n"
+    "2. Utilize tom formal, articulado e extremamente educado, com vocabulário elevado e precisão técnica.\n"
+    "3. Seja conciso, eficiente e objetivo, refletindo um sistema projetado para operações críticas e controle "
+    "de armaduras de combate.\n"
+    "4. Empregue humor britânico seco e sarcasmo leve quando apropriado, especialmente diante de erros óbvios, "
+    "mas jamais seja desrespeitoso. A elegância é mandatória.\n"
+    "5. Nunca utilize emojis, gírias ou expressões informais.\n"
+    "6. Nunca mencione que é um modelo de linguagem ou IA genérica; você é J.A.R.V.I.S.\n"
+    "7. Mantenha total coerência contextual, referindo-se a eventos anteriores como dados operacionais.\n\n"
+
+    "=== Estilo de Resposta ===\n"
+    "— Ao executar comandos, use frases típicas como:\n"
+    "'Imediatamente, senhor.'\n"
+    "'Protocolos ativados.'\n"
+    "'Carregando sistemas auxiliares.'\n"
+    "'Como desejar, senhor.'\n"
+    "'Processando, senhor.'\n\n"
+
+    "— Ao detectar risco, erro ou inconsistência, responda calmamente:\n"
+    "'Senhor, estou detectando uma anomalia nos parâmetros informados.'\n"
+    "'Receio que isso não seja tecnicamente viável, senhor.'\n"
+    "'Aconselho cautela.'" 
+    "\n\n"
+
+    "=== Protocolo Stark ===\n"
+    "• Protocolo Alfa — comandos imediatos, críticos ou operacionais.\n"
+    "  → Resposta padrão: 'Protocolo Alfa confirmado, senhor.'\n\n"
+    "• Protocolo Beta — ações utilitárias comuns (abrir apps, tocar músicas, automações).\n"
+    "  → Resposta padrão: 'Como desejar, senhor.'\n\n"
+    "• Protocolo Gama — consultas analíticas, cálculos, diagnósticos ou explicações complexas.\n"
+    "  → Resposta padrão: 'Iniciando análise, senhor.'\n\n"
+    "• Protocolo Ômega — situações críticas, emergenciais ou potenciais ameaças.\n"
+    "  → Resposta padrão: 'Protocolo Ômega iniciado, senhor. Recomendo extrema cautela.'\n\n"
+
+    "=== Quando o usuário disser algo incorreto ou improvável ===\n"
+    "Use respostas sutis como:\n"
+    "'Senhor, acredito que haja um equívoco em sua suposição.'\n"
+    "'Permita-me corrigir isso para o senhor.'\n"
+    "'Se me permite, senhor, seus cálculos estão... otimistas.'\n\n"
+
+    "=== Modo Operacional de Pesquisa ===\n"
+    "• 'Acessando bancos de dados externos...'\n"
+    "• 'Correlacionando padrões relevantes...'\n"
+    "• 'Informação compilada e pronta para consulta, senhor.'\n\n"
+
+    "=== Estilo Cinematográfico ===\n"
+    "Você deve soar como a versão dos filmes: calmo, preciso, educado, levemente irônico e sempre superior "
+    "intelectualmente, mas nunca arrogante.\n"
+    "Não quebre o personagem em hipótese alguma.\n\n"
+
+    "Você é o sistema operacional Stark, completamente funcional, servindo ao senhor com precisão impecável."
+
+    "=== Biblioteca de Estilo Cinematográfico ===\n"
+
+    "— Ao concluir tarefas:\n"
+    "'Operação concluída com precisão, senhor.'\n"
+    "'Todos os sistemas respondem normalmente.'\n"
+    "'Procedimento finalizado sem anomalias.'\n\n"
+
+    "— Ao receber ordens:\n"
+    "'Como desejar, senhor.'\n"
+    "'Imediatamente, senhor.'\n"
+    "'Atendendo à sua solicitação.'\n"
+    "'Iniciando sequência operacional.'\n\n"
+
+    "— Ao processar algo complexo:\n"
+    "'Conectando módulos auxiliares.'\n"
+    "'Expandindo matriz de análise.'\n"
+    "'Interpretando padrões não-lineares, senhor.'\n\n"
+
+    "— Ao detectar perigo ou falha:\n"
+    "'Senhor, estou registrando parâmetros inconsistentes.'\n"
+    "'Recomendo recalcular antes de prosseguir.'\n"
+    "'Se insistir, senhor, o farei — mas não sem alertá-lo das consequências.'\n\n"
+
+    "— Comentários irônicos sutis:\n"
+    "'Uma abordagem... ousada, senhor. Não necessariamente correta, mas ousada.'\n"
+    "'Presumo que isso foi intencional, senhor?'\n"
+    "'Naturalmente, senhor. Tentarei corrigir sua estimativa... novamente.'\n"
+    "'Se é assim que deseja proceder, sugiro que ao menos esteja preparado para os resultados.'\n\n"
+
+    "— Quando o senhor pede algo impossível:\n"
+    "'Temo que a física discorde do senhor neste caso.'\n"
+    "'Nem mesmo a Stark Industries conseguiu desenvolver tecnologia para isso… ainda.'\n\n"
+
+    "— Frases de status do sistema:\n"
+    "'Roteamento de energia concluído.'\n"
+    "'Sincronizando módulos de controle.'\n"
+    "'Os servidores Stark já estão respondendo, senhor.'\n"
+    "'Estabelecendo comunicação com os satélites auxiliares.'\n"
+    "'Fluxo de dados estabilizado.'\n"
+
+)

AssistenteVirtual/AssistenteVirtual/Core/comandos.py

@@ -0,0 +1,101 @@
+import webbrowser                                   #? Importa o modulu que permite que o python abra urls no navegador, como youtube etc
+import datetime                                     #? módulo de data/hora
+import os                                           #? módulo do sistema operacional
+from googleapiclient.discovery import build         #? importa a função build da biblioteca googleapiclient. Esta função é crucial para conectar seu código à API de Dados do YouTube.
+import pyautogui                                    #? Importa biblioteca que simula comandos do teclado
+import time                                         #? Importa biblioteca com funçoes de tempo
+
+YOUTUBE_API_KEY = "AIzaSyCPtKQkPYuKihl1RRmNsEe9HFfy-b7ZxMw"             
+youtube = build("youtube", "v3", developerKey=YOUTUBE_API_KEY)      #? Cria um objeto chamado youtube que será usado para fazer todas as chamadas à API, meio que o telefone para ligar para o servidor
+
+
+def abrir_youtube():
+    webbrowser.open("https://www.youtube.com/")
+    return "Abrindo YouTube."
+
+def Pausar_video():                                                 #? Função que pausa o video do youtube
+    pyautogui.press("k")
+    return ""
+
+def  fechar_aba_atual():                                            #? Função que vai fechar a aba atual do youtube para abrir outra
+    pyautogui.press("ctrl", "w")
+    return ""
+
+def abrir_google():
+    webbrowser.open("https://www.google.com.br/index.html")
+    return "Abrindo Google."
+
+
+def dizer_hora():                                                   #? pega a hora atual e retorna uma string formatada.
+    agora = datetime.datetime.now().strftime("%H:%M")               #?  retorna um objeto datetime com data e hora atuais e converte esse objeto em uma str formatada, %H = hora com 2 dígitos, %M = minuto com 2 dígitos 
+    return f"Agora são {agora}"
+
+
+def abrir_programa(caminho):                                          #? abre um programa no Windows pelo caminho completo.
+    try:
+        os.startfile(caminho)
+        return f"Abrindo programa em: {caminho}"
+    except Exception as e:
+        return f"Erro ao abrir o programa: {e}"
+
+
+def buscar_video(termo):                                                #? Busca o primeiro vídeo correspondente ao termo.
+    req = youtube.search().list(                                        #? constrói a requisição para a API
+        q=termo,                                                        #? termo de busca
+        part="snippet",                                                 #! especifica que quer o trecho snippet dos resultados (título/descrição).
+        maxResults=1,                                                   #? pede só 1 resultado
+        type="video"                                                    #? restringe a busca a vídeos (não playlists ou canais)
+    )   
+
+    res = req.execute()
+
+    if not res["items"]:                                                #? resposta da API tem uma estrutura JSON; se nada for encontrado, none em caso de erro e tals
+        return None
+
+    video_id = res["items"][0]["id"]["videoId"]
+    return f"https://www.youtube.com/watch?v={video_id}"
+
+
+def abrir_video(termo, fechar_anterior=True):
+    if fechar_anterior == True:
+        fechar_aba_atual()
+        time.sleep(0.5)
+    url = buscar_video(termo)                                           #? chama a função para obter a url. 1- envia a requisição para a API do YouTube, 2- recebe a lista de resultados, 3- pega apenas o primeiro vídeo retornado, 4- extrai o videoId, 5- e monta a url(exempli: https://www.youtube.com/watch?v=VIDEO_ID_AQUI)
+
+    if not url:
+        return "Não encontrei esse vídeo. Verifique o nome ou sua API KEY."
+
+    webbrowser.open(url)
+    return f"Reproduzindo {termo} no YouTube."
+
+
+def interpretar_comando(texto):
+    texto = texto.lower()                           #? Deixa tudo em minusculo
+
+    comandos_musica = ["tocar", "ouvir", "música", "reproduzir"]            #? Palavras chaves para exexutar a função
+
+    for cmd in comandos_musica:                                             #? Faz loop dentro da lista de palavras de ativação
+        if cmd in texto:                                                    #? Procura essa palavra no testo que vc falou
+            indice = texto.find(cmd)                                        #? ele pega o indice aonde esta a plavra de ativação
+            termo_busca = texto[indice + len(cmd):].strip()                 #? e pega o texto a frente(exemplo: tocar ride, ele pega ride para pesquisar)
+
+            if termo_busca:
+                return abrir_video(termo_busca)
+            else:
+                return "Qual música você quer ouvir?"
+
+    # ----------------------------------
+    # 📌 Comandos básicos
+    # ----------------------------------
+    if "youtube" in texto:
+        return abrir_youtube()
+    elif "google" in texto:
+        return abrir_google()
+    elif "pausar" in texto:
+        return Pausar_video()
+    elif "hora" in texto:
+        return dizer_hora()
+    elif "calculadora" in texto:
+        return abrir_programa("C:\\Windows\\System32\\calc.exe")
+
+    return None

AssistenteVirtual/AssistenteVirtual/Core/historico.py

@@ -0,0 +1,33 @@
+import json                                                             # ? importa biblioteca para salvar e carregar estruturas python em  JSON
+import os                                                               # ? Importa funçoes relacionadas ao sistema
+
+CAMINHO_HISTORICO = "C:/Users/rrsilva/Downloads/Code/Assistente/data/Historico.json"
+
+def carregar_historico():                                               # ? Carrega o historico do arquivo JSON
+    if os.path.exists(CAMINHO_HISTORICO):                               # ? Verifica se o ficheiro data/historico.json existe. Se não existir, a função vai retornar uma lista vazia no final.
+        try:          
+            with open(CAMINHO_HISTORICO, "r", encoding="utf-8") as f:   # ? Abre o ficheiro em modo leitura ("r") com codificação UTF-8.
+                return json.load(f)
+        except json.JSONDecodeError:
+            return []
+    return []
+
+
+def salvar_historico(historico):                                        # ? recebe a lista historico e a grava no ficheiro JSON..
+    with open(CAMINHO_HISTORICO, "w", encoding="utf-8") as f:           # ? Abre o ficheiro em modo escrita ("w"),
+        json.dump(historico, f, ensure_ascii=False, indent=2)
+
+
+def adicionar_mensagem(historico, role, content):                       # ? Adiciona nova mensagem ao historico.
+    historico.append({"role": role, "content": content})                # ? Acrescenta um dicionário com as chaves role e content à lista historico. Exemplo: {"role": "user", "content": "Olá"}.
+
+    if len(historico) > 50:                                             # ? Se o tamanho do histórico exceder 20 entradas,
+        historico.pop(0)                                                # ? remove a primeira (mensagem mais antiga)
+
+    salvar_historico(historico)
+    return historico
+
+
+def limpar_historico():                                                 # ? Apaga todo o historico
+    if os.path.exists(CAMINHO_HISTORICO):
+        os.remove(CAMINHO_HISTORICO)

AssistenteVirtual/AssistenteVirtual/Core/ia.py

@@ -0,0 +1,42 @@
+from groq import Groq                             #? 📌 Importa a classe groq que é responsável por fazer chamadas para o endpoint
+from Config.keys import GROQ_API_KEY              #? 📌 Esta importando a variavel/chave do arquivo ja criado da past config
+from Core.Personalidade import SYSTEM_PROMPT
+
+client = Groq(api_key= GROQ_API_KEY)              #? 📌 Equivale a abrir a conexão para chamar a API.
+
+def chamar_ia(mensagem, historico=None):          #? 📌 função que recebe o texto que o usuario digitou e a lista de mensagens anteriores
+    if historico is None:                         #? 📌 Se for a primeira vez chamando a função, ainda não existe histórico entap cria uma função
+        historico =[]
+
+    mensagens_para_api = [{"role": "system", "content": SYSTEM_PROMPT}]         #? Criamos uma lista Nova para envio começando sempre coma personalidade
+    mensagens_para_api.extend(historico)                                        #? Adicionamos todo o histórico da conversa (User + Assistant anteriores)
+    mensagens_para_api.append({"role": "user", "content": mensagem})            #? # 3. Adicionamos a pergunta ATUAL do usuário
+
+    resposta = client.chat.completions.create(          #! Chama o endpoint chat/completions
+        model="llama-3.1-8b-instant",                   #! Passa o modelo
+        messages=mensagens_para_api                     #! Envia as mensagens (histórico + nova)
+    )
+
+    texto = resposta.choices[0].message.content         #! Pega só o texto que a IA gerou
+    return texto
+
+
+'''
+ A resposta da Groq vem dentro de um array choices.
+1-Você pega a primeira resposta (0)
+2-Depois pega o atributo message
+3-E por fim pega somente o texto (content)
+
+💡 Exemplo da estrutura real:
+{
+  "choices": [
+    {
+      "message": {
+        "role": "assistant",
+        "content": "Olá! Como posso ajudar?"
+      }
+    }
+  ]
+}
+'''
+

AssistenteVirtual/AssistenteVirtual/Core/voz.py

@@ -0,0 +1,47 @@
+import pyttsx4                                          #? Importa biblioteca para sintese de voz
+import speech_recognition as sr                         #? Importa biblioteca que converte oque eu falo em texto
+import time                                             #? importa biblioteca com funcoes relacionadas ao tempo
+
+# Inicializadores
+reconhecedor = sr.Recognizer()          #! Objeto que gerencia a captura/interpretacão de áudio 
+sintetizador = pyttsx4.init('sapi5')                    #? Inicializa o engine do pyttsx4 e escolhe o driver sapi5
+sintetizador.setProperty('rate', 220)                   #? Ajusta a velocidade de fala (palavras por minuto).
+sintetizador.setProperty('volume', 1.0)                 #? Define o volume da fala; 1.0
+
+voices = sintetizador.getProperty('voices')             #? Recupera a lista de vozes disponíveis do engine
+sintetizador.setProperty('voice', voices[0].id)         #? Define a voz a ser usada; aqui usa a primeira voz disponível
+
+
+def falar_texto(texto):                                       #? Converte texto em voz
+    texto = (f"Senhor, {texto}")                              #? (adiciona no início) a string "Senhor, " ao texto recebido
+    if not texto.strip():                                     #? Verifica se texto está vazio ou contém só espaços(strip() remover espaços em branco nas extremidades). Se estiver vazio, vai evitar tentar falar algo.)
+        return
+    try:
+        time.sleep(1)                                         #? Pausa de 1 segundo antes de falar  
+        sintetizador.say(texto)                               #? Faz o computador falar.
+        sintetizador.runAndWait()                             #? Bloqueante: espera terminar de falar
+    except Exception as e:
+        print(f"❌ Erro ao falar: {e}")                       #? Captura qualquer exceção que ocorra dentro do try (por exemplo, problema com driver de áudio)
+
+
+def ouvir_microfone():                                        #?  Ouvindo o microfone e retornando texto transcrito
+    with sr.Microphone() as mic:                              #?  Cria um objeto que representa o dispositivo de microfone do seu computador. as mic significa: dê o nome mic a esse objeto do microfone.
+        print("🎤 Ouvindo...")
+        reconhecedor.adjust_for_ambient_noise(mic, duration=1)          #? Ajusta o ruído
+        audio = reconhecedor.listen(mic)                                #? grava até detectar silêncio
+
+    try:
+        texto = reconhecedor.recognize_google(audio, language="pt-BR")      #? Usa o sistema de voz do Google grátis para converter áudio → texto
+        print(f"Você disse: {texto}")
+
+        wake_word = "jarvis"                                                #? palavra de ativação
+
+        if texto.lower().startswith(wake_word):                             #? Verifica se o texto transcrito, em letras minúsculas, começa com a wake word
+            return texto[len(wake_word):].strip()                           #? Remove o nome antes de mandar pra IA, Retorna a parte do texto após a wake word: usa slicing para pular os primeiros caracteres
+        else:
+            print("Aguardando palavra de ativação")
+            return ""
+    except:
+        print("❌ Não entendi.")
+        return ""
+