Update app.py

app.py

@@ -1,148 +1,119 @@
-import streamlit as st
 import difflib
-import os
-import re
-import hashlib
+import streamlit as st
 from groq import Groq
+import os
 
-# --- Page config ---
-st.set_page_config(page_title="🚀 AI Assistant with Workflow + Semantic Search", layout="wide")
+# --- Set page config FIRST! ---
+st.set_page_config(page_title="AI Code Assistant", layout="wide")
+
+# --- Custom CSS for Professional Look ---
+st.markdown("""
+    <style>
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;600&display=swap');
+    html, body, [class*="css"]  {
+        font-family: 'Inter', sans-serif;
+        background-color: #f7f9fb;
+    }
+    .stApp {
+        background-color: #f7f9fb;
+    }
+    .stSidebar {
+        background-color: #22304a !important;
+    }
+    .stButton>button {
+        background-color: #22304a;
+        color: #fff;
+        border-radius: 6px;
+        border: none;
+        font-weight: 600;
+        padding: 0.5rem 1.5rem;
+        margin-top: 0.5rem;
+        margin-bottom: 0.5rem;
+        transition: background 0.2s;
+    }
+    .stButton>button:hover {
+        background-color: #1a2333;
+        color: #fff;
+    }
+    .stTextInput>div>div>input, .stTextArea>div>textarea {
+        background: #fff;
+        border: 1px solid #d1d5db;
+        border-radius: 6px;
+        color: #22304a;
+        font-size: 1rem;
+    }
+    .stDownloadButton>button {
+        background-color: #22304a;
+        color: #fff;
+        border-radius: 6px;
+        border: none;
+        font-weight: 600;
+        padding: 0.5rem 1.5rem;
+        margin-top: 0.5rem;
+        margin-bottom: 0.5rem;
+        transition: background 0.2s;
+    }
+    .stDownloadButton>button:hover {
+        background-color: #1a2333;
+        color: #fff;
+    }
+    .stExpanderHeader {
+        font-weight: 600;
+        color: #22304a;
+        font-size: 1.1rem;
+    }
+    .stMarkdown {
+        color: #22304a;
+    }
+    .stAlert {
+        border-radius: 6px;
+    }
+    </style>
+""", unsafe_allow_html=True)
 
 # --- 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.")
+    st.error("GROQ_API_KEY environment variable not set. Please set it in your Hugging Face Space secrets.")
     st.stop()
 client = Groq(api_key=GROQ_API_KEY)
 
-# --- Cache for embeddings ---
-embedding_cache = {}
-
-def get_embedding(text):
-    key = hashlib.sha256(text.encode()).hexdigest()
-    if key in embedding_cache:
-        return embedding_cache[key]
-    embedding = [ord(c) % 100 / 100 for c in text[:512]]
-    embedding_cache[key] = embedding
-    return embedding
-
-def cosine_similarity(vec1, vec2):
-    dot = sum(a*b for a,b in zip(vec1, vec2))
-    norm1 = sum(a*a for a in vec1) ** 0.5
-    norm2 = sum(b*b for b in vec2) ** 0.5
-    return dot / (norm1 * norm2 + 1e-8)
-
-def split_code_into_chunks(code, lang):
-    if lang.lower() == "python":
-        pattern = r'(def\s+\w+\(.*?\):|class\s+\w+\(?.*?\)?:)'
-        splits = re.split(pattern, code)
-        chunks = []
-        for i in range(1, len(splits), 2):
-            header = splits[i]
-            body = splits[i+1] if (i+1) < len(splits) else ""
-            chunks.append(header + body)
-        return chunks if chunks else [code]
-    else:
-        return [code]
+# --- Blackbox AI Agent Setup ---
+BLACKBOX_API_KEY = os.environ.get("BLACKBOX_API_KEY")
+if not BLACKBOX_API_KEY:
+    st.error("BLACKBOX_API_KEY environment variable not set. Please set it in your Hugging Face Space secrets.")
+    st.stop()
+
+# Chat history management
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
 
-def groq_call(prompt):
-    resp = client.chat.completions.create(
+def groq_api_call(prompt):
+    chat_completion = 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)
-    scored_chunks = []
-    for chunk in chunks:
-        emb = get_embedding(chunk)
-        score = cosine_similarity(question_emb, emb)
-        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)
-    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"Explain which parts handle the question and how to modify them if needed."
-    )
-    return groq_call(prompt)
-
-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}"
-    )
-    return groq_call(prompt)
-
-def agentic_workflow(code, skill_level, programming_language, explanation_language, user_role):
-    timeline = []
-    suggestions = []
-
-    # 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}"
-    )
-    explanation = groq_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.")
-
-    # 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}"
-    )
-    refactor_response = groq_call(refactor_prompt)
-    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 ""
-                break
-        if not refactored_code:
-            refactored_code = refactor_response
-    else:
-        refactored_code = refactor_response
-    timeline.append({"step": "Refactor", "description": "Refactored code with improvements", "output": refactored_code, "code": refactored_code})
-    suggestions.append("Review the refactored code and adapt it to your style or project needs.")
-
-    # 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}"
-    )
-    review = groq_call(review_prompt)
-    timeline.append({"step": "Review", "description": "Code review and suggestions", "output": review, "code": refactored_code})
-    suggestions.append("Incorporate review feedback for cleaner, robust code.")
-
-    # Error detection & fixes
-    errors = error_detection_and_fixes(refactored_code, programming_language, skill_level, user_role, explanation_language)
-    timeline.append({"step": "Error Detection", "description": "Bugs, security, performance suggestions", "output": errors, "code": refactored_code})
-    suggestions.append("Apply fixes to improve code safety and performance.")
-
-    # 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}"
-    )
-    tests = groq_call(test_prompt)
-    timeline.append({"step": "Test Generation", "description": "Generated unit tests", "output": tests, "code": tests})
-    suggestions.append("Run generated tests locally to validate changes.")
-
-    return timeline, suggestions
-
-def get_inline_diff_html(original, modified):
+    return chat_completion.choices[0].message.content
+
+def blackbox_ai_call(messages):
+    # This is a placeholder for actual Blackbox AI API call using BLACKBOX_API_KEY
+    # For demonstration, we simulate a response by echoing last user message
+    last_user_message = messages[-1]["content"] if messages else ""
+    response = f"Blackbox AI response to: {last_user_message}"
+    return response
+
+def get_diff_html(original, modified):
+    original_lines = original.splitlines()
+    modified_lines = modified.splitlines()
     differ = difflib.HtmlDiff(tabsize=4, wrapcolumn=80)
-    html = differ.make_table(
-        original.splitlines(), modified.splitlines(),
-        "Original", "Refactored", context=True, numlines=2
-    )
-    return f'<div style="overflow-x:auto; max-height:400px;">{html}</div>'
+    return differ.make_table(original_lines, modified_lines, "Original", "Modified", context=True, numlines=2)
+
+def code_complexity(code):
+    lines = code.count('\n') + 1
+    functions = code.count('def ')
+    classes = code.count('class ')
+    comments = code.count('#')
+    return f"Lines: {lines}, Functions: {functions}, Classes: {classes}, Comments: {comments}"
 
 def detect_code_type(code, programming_language):
     backend_keywords = [
@@ -172,156 +143,258 @@ def detect_code_type(code, programming_language):
         return 'frontend'
     return 'unknown'
 
-def code_complexity(code):
-    lines = code.count('\n') + 1
-    functions = code.count('def ')
-    classes = code.count('class ')
-    comments = code.count('#')
-    return f"Lines: {lines}, Functions: {functions}, Classes: {classes}, Comments: {comments}"
-
 def code_matches_language(code: str, language: str) -> bool:
-    """Strictly check whether code matches key patterns of the selected language."""
-    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
-        ],
-        "c++": [
-            "#include", "int main(", "std::", "::", "cout <<", "cin >>", "new ", "delete ",
-            "try {", "catch(", "template<", "using namespace", "class ", "struct ", "#define",
-        ],
-        "java": [
-            "package ", "import java.", "public class", "private ", "protected ", "public static void main",
-            "System.out.println", "try {", "catch(", "throw new ", "implements ", "extends ",
-            "@Override", "interface ", "enum ", "synchronized ", "final ",
-        ],
-        "c#": [
-            "using System", "namespace ", "class ", "interface ", "public static void Main",
-            "Console.WriteLine", "try {", "catch(", "throw ", "async ", "await ", "get;", "set;",
-            "List<", "Dictionary<", "[Serializable]", "[Obsolete]",
-        ],
-        "javascript": [
-            "function ", "const ", "let ", "var ", "document.", "window.", "console.log",
-            "if(", "for(", "while(", "switch(", "try {", "catch(", "export ", "import ", "async ",
-            "await ", "=>", "this.", "class ", "prototype", "new ", "$(",
-        ],
-        "typescript": [
-            "function ", "const ", "let ", "interface ", "type ", ": string", ": number", ": boolean",
-            "implements ", "extends ", "enum ", "public ", "private ", "protected ", "readonly ",
-            "import ", "export ", "console.log", "async ", "await ", "=>", "this.",
-        ],
-        "html": [
-            "<!doctype html", "<html", "<head>", "<body>", "<script", "<style", "<meta ", "<link ",
-            "<title>", "<div", "<span", "<p>", "<h1>", "<ul>", "<li>", "<form", "<input", "<button",
-            "<table", "<footer", "<header", "<section", "<article", "<nav", "<img", "<a ", "</html>",
-        ],
-    }
+    code = code.strip().lower()
+    if language.lower() == "python":
+        return "def " in code or "import " in code or ".py" in code
+    if language.lower() == "c++":
+        return "#include" in code or "int main" in code or ".cpp" in code or "std::" in code
+    if language.lower() == "java":
+        return "public class" in code or "public static void main" in code or ".java" in code
+    if language.lower() == "c#":
+        return "using system" in code or "namespace" in code or ".cs" in code
+    if language.lower() == "javascript":
+        return "function " in code or "const " in code or "let " in code or "var " in code or ".js" in code
+    if language.lower() == "typescript":
+        return "function " in code or "const " in code or "let " in code or "var " in code or ": string" in code or ".ts" in code
+    if language.lower() == "html":
+        return "<html" in code or "<!doctype html" in code
+    return True  # fallback
 
-    match_patterns = patterns.get(language, [])
-    match_count = sum(1 for pattern in match_patterns if pattern in code_lower)
-
-    # Require at least one pattern to match for validation to succeed
-    return match_count >= 1
-
-
-# --- Sidebar ---
-st.sidebar.title("🔧 Configuration")
-lang = st.sidebar.selectbox("Programming Language", ["Python", "JavaScript", "C++", "Java", "C#", "TypeScript"])
-skill = st.sidebar.selectbox("Skill Level", ["Beginner", "Intermediate", "Expert"])
-role = st.sidebar.selectbox("Your Role", ["Student", "Frontend Developer", "Backend Developer", "Data Scientist"])
-explain_lang = st.sidebar.selectbox("Explanation Language", ["English", "Spanish", "Chinese", "Urdu"])
-st.sidebar.markdown("---")
-st.sidebar.markdown("<span style='color:#fff;'>Powered by <b>BLACKBOX.AI</b></span>", unsafe_allow_html=True)
-
-tabs = st.tabs(["🧠 Full AI Workflow", "🔍 Semantic Search"])
-# --- Tab 1: Full AI Workflow ---
-with tabs[0]:
-    st.title("🧠 Full AI Workflow")
-    file_types = {
-        "Python": ["py"],
-        "JavaScript": ["js"],
-        "C++": ["cpp", "h", "hpp"],
-        "Java": ["java"],
-        "C#": ["cs"],
-        "TypeScript": ["ts"],
-    }
+def agentic_workflow(code, skill_level, programming_language, explanation_language, user_role):
+    timeline = []
+    suggestions = []
 
-    uploaded_file = st.file_uploader(
-        f"Upload {', '.join(file_types.get(lang, []))} file(s)", 
-        type=file_types.get(lang, None)
+    explain_prompt = (
+        f"Explain the following {programming_language} code line by line or function by function "
+        f"for a {skill_level.lower()} {user_role} in {explanation_language}:\n{code}"
+    )
+    explanation = groq_api_call(explain_prompt)
+    timeline.append({
+        "step": "Explain",
+        "description": "Step-by-step explanation of your code.",
+        "output": explanation,
+        "code": code
+    })
+    suggestions.append("Refactor your code for better readability and performance.")
+
+    refactor_prompt = (
+        f"Refactor the following {programming_language} code for better readability, performance, and structure. "
+        f"Explain what changes you made and why, for a {skill_level.lower()} {user_role} in {explanation_language}:\n{code}"
     )
-    if uploaded_file:
-        code_input = uploaded_file.read().decode("utf-8")
+    refactor_response = groq_api_call(refactor_prompt)
+    if "```" in refactor_response:
+        parts = refactor_response.split("```")
+        refactor_explanation = parts[0].strip()
+        refactored_code = ""
+        for i in range(1, len(parts)):
+            if parts[i].strip().startswith(programming_language.lower()):
+                refactored_code = parts[i].strip().split('\n', 1)[1] if '\n' in parts[i] else ""
+                break
+            elif i == 1:
+                refactored_code = parts[i].strip().split('\n', 1)[1] if '\n' in parts[i] else ""
+        if not refactored_code:
+            refactored_code = refactor_response.strip()
     else:
-        code_input = st.text_area("Your Code", height=300, placeholder="Paste your code here...")
-
-    if code_input:
-        st.markdown(f"<b>Complexity:</b> {code_complexity(code_input)}", unsafe_allow_html=True)
-
-    if st.button("Run AI Workflow"):
-        if not code_input.strip():
-            st.warning("Please paste or upload your code.")
-        elif not code_matches_language(code_input, lang):
-            st.error(f"The pasted code doesn’t look like valid {lang} code. Please check your code or select the correct language.")
-        else:  
-            code_type = detect_code_type(code_input, lang)
-            if code_type == "data_science" and role != "Data Scientist":
-                st.error("Data science code detected. Please select 'Data Scientist' role.")
-            elif code_type == "frontend" and role != "Frontend Developer":
-                st.error("Frontend code detected. Please select 'Frontend Developer' role.")
-            elif code_type == "backend" and role != "Backend Developer":
-                st.error("Backend code detected. Please select 'Backend Developer' role.")
+        refactor_explanation = "Refactored code below."
+        refactored_code = refactor_response.strip()
+    timeline.append({
+        "step": "Refactor",
+        "description": refactor_explanation,
+        "output": refactored_code,
+        "code": refactored_code
+    })
+    suggestions.append("Review the refactored code for best practices and improvements.")
+
+    review_prompt = (
+        f"Provide a code review for the following {programming_language} code. "
+        f"Include feedback on best practices, code smells, optimization, and security issues, for a {skill_level.lower()} {user_role} in {explanation_language}:\n{refactored_code}"
+    )
+    review_feedback = groq_api_call(review_prompt)
+    timeline.append({
+        "step": "Review",
+        "description": "AI code review and feedback.",
+        "output": review_feedback,
+        "code": refactored_code
+    })
+    suggestions.append("Generate unit tests for your code.")
+
+    test_prompt = (
+        f"Write unit tests for the following {programming_language} code. "
+        f"Use pytest style and cover all functions. For a {skill_level.lower()} {user_role} in {explanation_language}:\n{refactored_code}"
+    )
+    test_code = groq_api_call(test_prompt)
+    timeline.append({
+        "step": "Test Generation",
+        "description": "AI-generated unit tests for your code.",
+        "output": test_code,
+        "code": test_code
+    })
+    suggestions.append("Run the generated tests in your local environment.")
+
+    return timeline, suggestions
+
+st.markdown(
+    "<h2 style='text-align: center; color: #22304a; font-weight: 600; margin-bottom: 0.5em;'>AI Code Assistant</h2>",
+    unsafe_allow_html=True
+)
+
+with st.sidebar:
+    st.title("Settings")
+    programming_language = st.selectbox(
+        "Programming Language",
+        ["Python", "C++", "Java", "C#", "JavaScript", "TypeScript", "HTML"]
+    )
+    explanation_language = st.selectbox(
+        "Explanation Language",
+        ["English", "Urdu", "Chinese", "Spanish"]
+    )
+    skill_level = st.selectbox("Skill Level", ["Beginner", "Intermediate", "Expert"])
+    user_role = st.selectbox(
+        "Choose Role",
+        ["Data Scientist", "Backend Developer", "Frontend Developer", "Student"]
+    )
+    st.markdown("---")
+    st.markdown("<span style='color:#fff;'>Powered by <b>BLACKBOX.AI</b></span>", unsafe_allow_html=True)
+
+if "code" not in st.session_state:
+    st.session_state.code = ""
+if "timeline" not in st.session_state:
+    st.session_state.timeline = []
+if "suggestions" not in st.session_state:
+    st.session_state.suggestions = []
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+
+col1, col2 = st.columns([2, 3], gap="large")
+
+with col1:
+    st.subheader(f"{programming_language} Code")
+    uploaded_file = st.file_uploader(f"Upload .{programming_language.lower()} file", type=[programming_language.lower()])
+    code_input = st.text_area(
+        "Paste or edit your code here:",
+        height=300,
+        value=st.session_state.code,
+        key="main_code_input"
+    )
+    if uploaded_file is not None:
+        code = uploaded_file.read().decode("utf-8")
+        st.session_state.code = code
+        st.success("File uploaded successfully.")
+    elif code_input:
+        st.session_state.code = code_input
+
+    st.markdown(f"<b>Complexity:</b> {code_complexity(st.session_state.code)}", unsafe_allow_html=True)
+
+    st.markdown("---")
+    st.markdown("#### Agent Suggestions")
+    for suggestion in st.session_state.suggestions[-3:]:
+        st.markdown(f"- {suggestion}")
+
+    st.markdown("---")
+    st.markdown("#### Download Full Report")
+    if st.session_state.timeline:
+        report = ""
+        for step in st.session_state.timeline:
+            report += f"## {step['step']}\n{step['description']}\n\n{step['output']}\n\n"
+        st.download_button("Download Report", report, file_name="ai_code_assistant_report.txt")
+
+with col2:
+    st.subheader("Agentic Workflow")
+    if st.button("Run Full AI Agent Workflow"):
+        if not st.session_state.code.strip():
+            st.warning("Please enter or upload code first.")
+        else:
+            # Language check
+            if not code_matches_language(st.session_state.code, programming_language):
+                st.error(f"It looks like you provided code in a different language. Please provide {programming_language} code.")
             else:
-                with st.spinner("Running agentic workflow..."):
-                    timeline, suggestions = agentic_workflow(code_input, skill, lang, explain_lang, role)
-                
-                # Show each step in an expander
-                for step in timeline:
-                    with st.expander(f"✅ {step['step']} - {step['description']}"):
-                        if step['step'] == "Refactor":
-                            diff_html = get_inline_diff_html(code_input, step['code'])
-                            st.markdown(diff_html, unsafe_allow_html=True)
-                            st.code(step['output'], language=lang.lower())
-                        else:
-                            st.markdown(step['output'])
-
-                st.markdown("#### Agent Suggestions")
-                for s in suggestions:
-                    st.markdown(f"- {s}")
-
-                # Download buttons after suggestions
-                st.markdown("---")
-                st.markdown("### 📥 Download Results")
-
-                report_text = ""
-                for step in timeline:
-                    report_text += f"## {step['step']}\n{step['description']}\n\n{step['output']}\n\n"
-
-                st.download_button(
-                    label="📄 Download Full Workflow Report",
-                    data=report_text,
-                    file_name="ai_workflow_report.txt",
-                    mime="text/plain",
-                )
-
-                
-
-# --- Tab 2: Semantic Search ---
-with tabs[1]:
-    st.title("🔍 Semantic Search")
-    sem_code = st.text_area("Your Code", height=300, placeholder="Paste your code...")
-    sem_q = st.text_input("Your Question", placeholder="E.g., What does this function do?")
-    if st.button("Run Semantic Search"):
-        if not sem_code.strip() or not sem_q.strip():
-            st.warning("Code and question required.")
+                code_type = detect_code_type(st.session_state.code, programming_language)
+                # Role/code type enforcement
+                if code_type == "data_science" and user_role != "Data Scientist":
+                    st.error("It looks like you provided data science code. Please select 'Data Scientist' as your role.")
+                elif code_type == "frontend" and user_role != "Frontend Developer":
+                    st.error("It looks like you provided frontend code. Please select 'Frontend Developer' as your role.")
+                elif code_type == "backend" and user_role != "Backend Developer":
+                    st.error("It looks like you provided backend code. Please select 'Backend Developer' as your role.")
+                elif code_type == "unknown":
+                    st.warning("Could not determine the code type. Please make sure your code is complete and clear.")
+                else:
+                    with st.spinner("AI Agent is working through all steps..."):
+                        timeline, suggestions = agentic_workflow(
+                            st.session_state.code,
+                            skill_level,
+                            programming_language,
+                            explanation_language,
+                            user_role
+                        )
+                        st.session_state.timeline = timeline
+                        st.session_state.suggestions = suggestions
+                    st.success("Agentic workflow complete. See timeline below.")
+
+    # Chatbox with history using Blackbox AI agent
+    st.subheader("Chat with Blackbox AI Agent")
+    user_input = st.text_input("Enter your message:", key="chat_input")
+    if user_input:
+        st.session_state.chat_history.append({"role": "user", "content": user_input})
+        response = blackbox_ai_call(st.session_state.chat_history)
+        st.session_state.chat_history.append({"role": "assistant", "content": response})
+
+    for chat in st.session_state.chat_history:
+        if chat["role"] == "user":
+            st.markdown(f"**You:** {chat['content']}")
         else:
-            with st.spinner("Running semantic search..."):
-                answer = semantic_search_improved(sem_code, sem_q, lang, skill, role, explain_lang)
-                st.markdown("### 📌 Answer")
-                st.markdown(answer)
+            st.markdown(f"**Blackbox AI:** {chat['content']}")
+
+# --- Semantic Search with history ---
+st.markdown("---")
+st.subheader("Semantic Search with Contextual History")
+
+if "semantic_search_history" not in st.session_state:
+    st.session_state.semantic_search_history = []
+
+sem_code = st.text_area("Your Code for Semantic Search", height=300, placeholder="Paste your code here...")
+sem_question = st.text_input("Ask a question about your code:")
+
+if st.button("Ask Semantic Search"):
+    if not sem_code.strip() or not sem_question.strip():
+        st.warning("Please provide both code and a question.")
+    else:
+        # Append current question to history
+        st.session_state.semantic_search_history.append({"question": sem_question, "answer": None})
+
+        # Build context from history
+        context = ""
+        for entry in st.session_state.semantic_search_history:
+            if entry["answer"]:
+                context += f"Q: {entry['question']}\nA: {entry['answer']}\n\n"
+            else:
+                context += f"Q: {entry['question']}\n"
+
+        # Combine context with current code and question
+        prompt = (
+            f"You are a helpful {programming_language} expert assisting a user.\n"
+            f"Here is the code:\n{sem_code}\n\n"
+            f"Conversation history:\n{context}\n"
+            f"Please answer the latest question."
+        )
+
+        # Call Blackbox AI agent with accumulated context
+        # For demonstration, we use semantic_search_improved as placeholder
+        answer = semantic_search_improved(sem_code, sem_question, programming_language, skill_level, user_role, explanation_language)
+
+        # Update the last answer in history
+        st.session_state.semantic_search_history[-1]["answer"] = answer
+
+        st.markdown("### Answer")
+        st.markdown(answer)
+
+if st.session_state.semantic_search_history:
+    st.markdown("### Semantic Search History")
+    for entry in st.session_state.semantic_search_history:
+        st.markdown(f"**Q:** {entry['question']}")
+        if entry["answer"]:
+            st.markdown(f"**A:** {entry['answer']}")
 
 st.markdown("---")
+st.markdown('<div style="text-align: center; color: #22304a; font-size: 1rem; margin-top: 2em;">Powered by <b>BLACKBOX.AI</b></div>', unsafe_allow_html=True)