Update app.py

app.py

@@ -1,19 +1,36 @@
 import streamlit as st
 import difflib
-import os
 import re
 import hashlib
-from groq import Groq
-
-# --- Page config ---
-st.set_page_config(page_title="🚀 AI Assistant with Workflow + Semantic Search", layout="wide")
+import requests
+import os
 
-# --- Groq API Setup ---
-GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
-if not GROQ_API_KEY:
-    st.error("❌ Please set your GROQ_API_KEY environment variable.")
+# --- Blackbox AI Agent Key (read from environment variable) ---
+BLACKBOX_API_KEY = os.environ.get("BLACKBOX_API_KEY")
+if not BLACKBOX_API_KEY:
+    st.error("❌ Please set your BLACKBOX_API_KEY environment variable.")
     st.stop()
-client = Groq(api_key=GROQ_API_KEY)
+BLACKBOX_API_URL = "https://api.blackbox.ai/v1/chat/completions"
+
+def blackbox_api_call(prompt):
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {BLACKBOX_API_KEY}",
+    }
+    data = {
+        "model": "gpt-4",
+        "messages": [
+            {"role": "user", "content": prompt}
+        ],
+        "max_tokens": 2048,
+        "temperature": 0.7
+    }
+    response = requests.post(BLACKBOX_API_URL, headers=headers, json=data)
+    if response.status_code == 200:
+        result = response.json()
+        return result["choices"][0]["message"]["content"]
+    else:
+        return f"[Blackbox API Error {response.status_code}]: {response.text}"
 
 # --- Cache for embeddings ---
 embedding_cache = {}
@@ -34,7 +51,7 @@ def cosine_similarity(vec1, vec2):
 
 def split_code_into_chunks(code, lang):
     if lang.lower() == "python":
-        pattern = r'(def\\s+\\w+\\(.*?\\):|class\\s+\\w+\\(?.*?\\)?:)'
+        pattern = r'(def\s+\w+\(.*?\):|class\s+\w+\(?.*?\)?:)'
         splits = re.split(pattern, code)
         chunks = []
         for i in range(1, len(splits), 2):
@@ -45,13 +62,6 @@ def split_code_into_chunks(code, lang):
     else:
         return [code]
 
-def groq_call(prompt):
-    resp = client.chat.completions.create(
-        messages=[{"role": "user", "content": prompt}],
-        model="llama3-70b-8192",
-    )
-    return resp.choices[0].message.content
-
 def semantic_search_improved(code, question, lang, skill, role, explain_lang):
     chunks = split_code_into_chunks(code, lang)
     question_emb = get_embedding(question)
@@ -62,21 +72,25 @@ def semantic_search_improved(code, question, lang, skill, role, explain_lang):
         scored_chunks.append((score, chunk))
     scored_chunks.sort(key=lambda x: x[0], reverse=True)
     top_chunks = [c for _, c in scored_chunks[:3]]
-    combined_code = "\\n\\n".join(top_chunks)
+    combined_code = "\n\n".join(top_chunks)
     prompt = (
-        f"You are a friendly and insightful {lang} expert helping a {skill} {role}.\\n"
-        f"Based on these relevant code snippets:\\n{combined_code}\\n"
-        f"Answer this question in {explain_lang}:\\n{question}\\n"
+        f"You are a friendly and insightful {lang} expert helping a {skill} {role}.\n"
+        f"Based on these relevant code snippets:\n{combined_code}\n"
+        f"Answer this question in {explain_lang}:\n{question}\n"
         f"Explain which parts handle the question and how to modify them if needed."
     )
-    return groq_call(prompt)
+    answer = blackbox_api_call(prompt)
+    add_to_blackbox_history(prompt, answer, "semantic_search")
+    return answer
 
 def error_detection_and_fixes(refactored_code, lang, skill, role, explain_lang):
     prompt = (
         f"You are a senior {lang} developer. Analyze this code for bugs, security flaws, "
-        f"and performance issues. Suggest fixes with explanations in {explain_lang}:\\n\\n{refactored_code}"
+        f"and performance issues. Suggest fixes with explanations in {explain_lang}:\n\n{refactored_code}"
     )
-    return groq_call(prompt)
+    answer = blackbox_api_call(prompt)
+    add_to_blackbox_history(prompt, answer, "workflow")
+    return answer
 
 def agentic_workflow(code, skill_level, programming_language, explanation_language, user_role):
     timeline = []
@@ -85,24 +99,26 @@ def agentic_workflow(code, skill_level, programming_language, explanation_langua
     # Explanation
     explain_prompt = (
         f"You are a friendly and insightful {programming_language} expert helping a {skill_level} {user_role}. "
-        f"Explain this code in {explanation_language} with clear examples, analogies, and why each part matters:\\n\\n{code}"
+        f"Explain this code in {explanation_language} with clear examples, analogies, and why each part matters:\n\n{code}"
     )
-    explanation = groq_call(explain_prompt)
+    explanation = blackbox_api_call(explain_prompt)
     timeline.append({"step": "Explain", "description": "Detailed explanation", "output": explanation, "code": code})
     suggestions.append("Consider refactoring your code to improve readability and performance.")
+    add_to_blackbox_history(explain_prompt, explanation, "workflow")
 
     # Refactor
     refactor_prompt = (
         f"Refactor this {programming_language} code. Explain the changes like a mentor helping a {skill_level} {user_role}. "
-        f"Include best practices and improvements:\\n\\n{code}"
+        f"Include best practices and improvements:\n\n{code}"
     )
-    refactor_response = groq_call(refactor_prompt)
+    refactor_response = blackbox_api_call(refactor_prompt)
+    add_to_blackbox_history(refactor_prompt, refactor_response, "workflow")
     if "```" in refactor_response:
         parts = refactor_response.split("```")
         refactored_code = ""
         for part in parts:
             if part.strip().startswith(programming_language.lower()):
-                refactored_code = part.strip().split('\\n', 1)[1] if '\\n' in part else ""
+                refactored_code = part.strip().split('\n', 1)[1] if '\n' in part else ""
                 break
         if not refactored_code:
             refactored_code = refactor_response
@@ -114,9 +130,10 @@ def agentic_workflow(code, skill_level, programming_language, explanation_langua
     # Review
     review_prompt = (
         f"As a senior {programming_language} developer, review the refactored code. "
-        f"Give constructive feedback on strengths, weaknesses, performance, security, and improvements in {explanation_language}:\\n\\n{refactored_code}"
+        f"Give constructive feedback on strengths, weaknesses, performance, security, and improvements in {explanation_language}:\n\n{refactored_code}"
     )
-    review = groq_call(review_prompt)
+    review = blackbox_api_call(review_prompt)
+    add_to_blackbox_history(review_prompt, review, "workflow")
     timeline.append({"step": "Review", "description": "Code review and suggestions", "output": review, "code": refactored_code})
     suggestions.append("Incorporate review feedback for cleaner, robust code.")
 
@@ -128,9 +145,10 @@ def agentic_workflow(code, skill_level, programming_language, explanation_langua
     # Test generation
     test_prompt = (
         f"Write clear, effective unit tests for this {programming_language} code. "
-        f"Explain what each test does in {explanation_language}, for a {skill_level} {user_role}:\\n\\n{refactored_code}"
+        f"Explain what each test does in {explanation_language}, for a {skill_level} {user_role}:\n\n{refactored_code}"
     )
-    tests = groq_call(test_prompt)
+    tests = blackbox_api_call(test_prompt)
+    add_to_blackbox_history(test_prompt, tests, "workflow")
     timeline.append({"step": "Test Generation", "description": "Generated unit tests", "output": tests, "code": tests})
     suggestions.append("Run generated tests locally to validate changes.")
 
@@ -173,7 +191,7 @@ def detect_code_type(code, programming_language):
     return 'unknown'
 
 def code_complexity(code):
-    lines = code.count('\\n') + 1
+    lines = code.count('\n') + 1
     functions = code.count('def ')
     classes = code.count('class ')
     comments = code.count('#')
@@ -182,12 +200,11 @@ def code_complexity(code):
 def code_matches_language(code: str, language: str) -> bool:
     code_lower = code.strip().lower()
     language = language.lower()
-
     patterns = {
         "python": [
             "def ", "class ", "import ", "from ", "try:", "except", "raise", "lambda",
-            "with ", "yield", "async ", "await", "print(", "self.", "__init__", "__name__",
-            "if __name__ == '__main__':", "#!",  # shebang for executable scripts
+            "with ", "yield", "async ", "await ", "print(", "self.", "__init__", "__name__",
+            "if __name__ == '__main__':", "#!",
         ],
         "c++": [
             "#include", "int main(", "std::", "::", "cout <<", "cin >>", "new ", "delete ",
@@ -219,12 +236,11 @@ def code_matches_language(code: str, language: str) -> bool:
             "<table", "<footer", "<header", "<section", "<article", "<nav", "<img", "<a ", "</html>",
         ],
     }
-
     match_patterns = patterns.get(language, [])
     match_count = sum(1 for pattern in match_patterns if pattern in code_lower)
     return match_count >= 1
 
-# --- Blackbox Agent Chat History (Session-only) ---
+# --- Chat History ---
 if 'blackbox_chat_history' not in st.session_state:
     st.session_state['blackbox_chat_history'] = []
 
@@ -243,11 +259,11 @@ def show_blackbox_history():
     else:
         for i, entry in enumerate(reversed(st.session_state['blackbox_chat_history'])):
             with st.sidebar.expander(f"{entry['mode'].replace('_', ' ').title()} #{len(st.session_state['blackbox_chat_history'])-i}"):
-                st.markdown(f"**Prompt:**\\n{entry['prompt']}")
-                st.markdown(f"**Response:**\\n{entry['response']}")
+                st.markdown(f"**Prompt:**\n{entry['prompt']}")
+                st.markdown(f"**Response:**\n{entry['response']}")
 
-# Show chat history in sidebar
-show_blackbox_history()
+# --- Page config ---
+st.set_page_config(page_title="🚀 AI Assistant with Workflow + Semantic Search", layout="wide")
 
 # --- Sidebar ---
 st.sidebar.title("🔧 Configuration")
@@ -258,6 +274,21 @@ explain_lang = st.sidebar.selectbox("Explanation Language", ["English", "Spanish
 st.sidebar.markdown("---")
 st.sidebar.markdown("<span style='color:#fff;'>Powered by <b>BLACKBOX.AI</b></span>", unsafe_allow_html=True)
 
+# Show chat history in sidebar
+show_blackbox_history()
+
+# Download chat history
+if st.session_state['blackbox_chat_history']:
+    chat_history_text = ""
+    for entry in st.session_state['blackbox_chat_history']:
+        chat_history_text += f"Mode: {entry['mode']}\nPrompt: {entry['prompt']}\nResponse: {entry['response']}\n\n"
+    st.sidebar.download_button(
+        label="Download Chat History",
+        data=chat_history_text,
+        file_name="blackbox_chat_history.txt",
+        mime="text/plain"
+    )
+
 tabs = st.tabs(["🧠 Full AI Workflow", "🔍 Semantic Search"])
 
 # --- Tab 1: Full AI Workflow ---
@@ -300,8 +331,7 @@ with tabs[0]:
             else:
                 with st.spinner("Running agentic workflow..."):
                     timeline, suggestions = agentic_workflow(code_input, skill, lang, explain_lang, role)
-                # Log to Blackbox chat history
-                add_to_blackbox_history(f"[Full Workflow] Code:\\n{code_input}", f"{timeline[-1]['output'] if timeline else ''}", mode='workflow')
+                
                 # Show each step in an expander
                 for step in timeline:
                     with st.expander(f"✅ {step['step']} - {step['description']}"):
@@ -322,7 +352,7 @@ with tabs[0]:
 
                 report_text = ""
                 for step in timeline:
-                    report_text += f"## {step['step']}\\n{step['description']}\\n\\n{step['output']}\\n\\n"
+                    report_text += f"## {step['step']}\n{step['description']}\n\n{step['output']}\n\n"
 
                 st.download_button(
                     label="📄 Download Full Workflow Report",
@@ -342,8 +372,6 @@ with tabs[1]:
         else:
             with st.spinner("Running semantic search..."):
                 answer = semantic_search_improved(sem_code, sem_q, lang, skill, role, explain_lang)
-                # Log to Blackbox chat history
-                add_to_blackbox_history(f"[Semantic Search] Q: {sem_q}\\nCode:\\n{sem_code}", answer, mode='semantic_search')
                 st.markdown("### 📌 Answer")
                 st.markdown(answer)