Update app.py

app.py

@@ -1,119 +1,148 @@
-import difflib
 import streamlit as st
-from groq import Groq
+import difflib
 import os
+import re
+import hashlib
+from groq import Groq
 
-# --- 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)
+# --- Page config ---
+st.set_page_config(page_title="🚀 AI Assistant with Workflow + Semantic Search", layout="wide")
 
 # --- Groq API Setup ---
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
 if not GROQ_API_KEY:
-    st.error("GROQ_API_KEY environment variable not set. Please set it in your Hugging Face Space secrets.")
+    st.error("❌ Please set your GROQ_API_KEY environment variable.")
     st.stop()
 client = Groq(api_key=GROQ_API_KEY)
 
-# --- 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 = []
+# --- 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]
 
-def groq_api_call(prompt):
-    chat_completion = client.chat.completions.create(
+def groq_call(prompt):
+    resp = client.chat.completions.create(
         messages=[{"role": "user", "content": prompt}],
         model="llama3-70b-8192",
     )
-    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)
-    return differ.make_table(original_lines, modified_lines, "Original", "Modified", context=True, numlines=2)
+    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 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 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):
+    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>'
 
 def detect_code_type(code, programming_language):
     backend_keywords = [
@@ -143,258 +172,179 @@ 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:
-    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
+    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>",
+        ],
+    }
 
-def agentic_workflow(code, skill_level, programming_language, explanation_language, user_role):
-    timeline = []
-    suggestions = []
+    match_patterns = patterns.get(language, [])
+    match_count = sum(1 for pattern in match_patterns if pattern in code_lower)
+    return match_count >= 1
 
-    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.")
+# --- Blackbox Agent Chat History (Session-only) ---
+if 'blackbox_chat_history' not in st.session_state:
+    st.session_state['blackbox_chat_history'] = []
 
-    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}"
-    )
-    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:
-        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
+def add_to_blackbox_history(prompt, response, mode):
+    st.session_state['blackbox_chat_history'].append({
+        'mode': mode,  # 'workflow' or 'semantic_search'
+        'prompt': prompt,
+        'response': response
     })
-    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
-)
+def show_blackbox_history():
+    st.sidebar.markdown('---')
+    st.sidebar.subheader('🕑 Blackbox Agent Chat History')
+    if not st.session_state['blackbox_chat_history']:
+        st.sidebar.info('No chat history this session.')
+    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']}")
+
+# Show chat history in sidebar
+show_blackbox_history()
+
+# --- 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"],
+    }
 
-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"]
+    uploaded_file = st.file_uploader(
+        f"Upload {', '.join(file_types.get(lang, []))} file(s)", 
+        type=file_types.get(lang, None)
     )
-    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:
-                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:
-            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.")
+    if uploaded_file:
+        code_input = uploaded_file.read().decode("utf-8")
     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"
+        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.")
             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)
+                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']}"):
+                        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.")
+        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)
+
+st.markdown("---")