Update app.py

app.py

@@ -1,378 +1,165 @@
 import streamlit as st
 import difflib
-import re
-import hashlib
 import requests
-import os
-
-# --- 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()
-BLACKBOX_API_URL = "https://api.blackbox.ai/v1/chat/completions"
+import datetime
+
+# --- CONFIG ---
+# Place your API keys here or use Streamlit secrets
+GROQ_API_KEY = st.secrets.get('GROQ_API_KEY', 'YOUR_GROQ_API_KEY')
+BLACKBOX_API_KEY = st.secrets.get('BLACKBOX_API_KEY', 'YOUR_BLACKBOX_API_KEY')
+
+PROGRAMMING_LANGUAGES = ["Python", "JavaScript", "TypeScript", "Java", "C++", "C#"]
+SKILL_LEVELS = ["Beginner", "Intermediate", "Expert"]
+USER_ROLES = ["Student", "Frontend Developer", "Backend Developer", "Data Scientist"]
+EXPLANATION_LANGUAGES = ["English", "Spanish", "Chinese", "Urdu"]
+EXAMPLE_QUESTIONS = [
+    "What does this function do?",
+    "How can I optimize this code?",
+    "What are the potential bugs in this code?",
+    "How does this algorithm work?",
+    "What design patterns are used here?",
+    "How can I make this code more readable?"
+]
+
+# --- API CALLS ---
+def call_groq_api(prompt, model="llama3-70b-8192"):
+    headers = {"Authorization": f"Bearer {GROQ_API_KEY}", "Content-Type": "application/json"}
+    data = {"model": model, "messages": [{"role": "user", "content": prompt}]}
+    response = requests.post("https://api.groq.com/openai/v1/chat/completions", json=data, headers=headers)
+    if response.status_code == 200:
+        return response.json()['choices'][0]['message']['content']
+    else:
+        return f"[Groq API Error] {response.text}"
 
-def blackbox_api_call(prompt):
+def call_blackbox_agent(prompt):
+    url = "https://api.blackboxai.dev/chat"
     headers = {
         "Content-Type": "application/json",
-        "Authorization": f"Bearer {BLACKBOX_API_KEY}",
+        "Authorization": f"Bearer {BLACKBOX_API_KEY}"
     }
     data = {
-        "model": "gpt-4",
-        "messages": [
-            {"role": "user", "content": prompt}
-        ],
-        "max_tokens": 2048,
-        "temperature": 0.7
+        "message": prompt
     }
-    response = requests.post(BLACKBOX_API_URL, headers=headers, json=data)
+    response = requests.post(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 = {}
-
-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]
+        # Adjust this if the response structure is different
+        return response.json().get("response", response.json())
     else:
-        return [code]
-
-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."
-    )
-    answer = blackbox_api_call(prompt)
-    add_to_blackbox_history(prompt, answer, "semantic_search")
-    return answer
+        return f"[Blackbox.ai API Error] {response.status_code}: {response.text}"
 
-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}"
-    )
-    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 = []
-    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 = 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")
+# --- UTILS ---
+def code_matches_language(code, language):
+    # Simple heuristic, can be improved
+    if language.lower() in code.lower():
+        return True
+    return True  # For demo, always True
 
-    # 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 = 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 ""
-                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 = 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.")
-
-    # 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 = 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.")
-
-    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 = [
-        'flask', 'django', 'express', 'fastapi', 'spring', 'controller', 'api', 'server', 'database', 'sql', 'mongoose'
-    ]
-    frontend_keywords = [
-        'react', 'vue', 'angular', 'component', 'html', 'css', 'document.getelementbyid', 'window.', 'render', 'jsx',
-        '<html', '<body', '<script', '<div', 'getelementbyid', 'queryselector', 'addeventlistener', 'innerhtml'
-    ]
-    data_science_keywords = [
-        'pandas', 'numpy', 'sklearn', 'matplotlib', 'seaborn', 'plt', 'train_test_split', 'randomforestclassifier', 'classification_report'
-    ]
-    code_lower = code.lower()
-    if any(word in code_lower for word in data_science_keywords):
-        return 'data_science'
-    if any(word in code_lower for word in frontend_keywords):
-        return 'frontend'
-    if programming_language.lower() in ['python', 'java', 'c#']:
-        if any(word in code_lower for word in backend_keywords):
-            return 'backend'
-    if programming_language.lower() in ['javascript', 'typescript', 'java', 'c#']:
-        if any(word in code_lower for word in frontend_keywords):
-            return 'frontend'
-    if programming_language.lower() in ['python', 'java', 'c#']:
-        return 'backend'
-    if programming_language.lower() in ['javascript', 'typescript']:
-        return 'frontend'
-    return 'unknown'
-
-def code_complexity(code):
+def calculate_code_complexity(code):
+    # Dummy complexity metric
     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_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__':", "#!",
-        ],
-        "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>",
-        ],
-    }
-    match_patterns = patterns.get(language, [])
-    match_count = sum(1 for pattern in match_patterns if pattern in code_lower)
-    return match_count >= 1
-
-# --- Chat History ---
-if 'blackbox_chat_history' not in st.session_state:
-    st.session_state['blackbox_chat_history'] = []
-
-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
-    })
-
-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']}")
-
-# --- Page config ---
-st.set_page_config(page_title="🚀 AI Assistant with Workflow + Semantic Search", layout="wide")
-
-# --- 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)
-
-# 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 ---
-with tabs[0]:
-    st.title("🧠 Full AI Workflow")
-    file_types = {
-        "Python": ["py"],
-        "JavaScript": ["js"],
-        "C++": ["cpp", "h", "hpp"],
-        "Java": ["java"],
-        "C#": ["cs"],
-        "TypeScript": ["ts"],
-    }
-
-    uploaded_file = st.file_uploader(
-        f"Upload {', '.join(file_types.get(lang, []))} file(s)", 
-        type=file_types.get(lang, None)
+    return f"{lines} lines"
+
+def get_inline_diff(original, modified):
+    diff = difflib.unified_diff(
+        original.splitlines(),
+        modified.splitlines(),
+        lineterm='',
+        fromfile='Original',
+        tofile='Refactored'
     )
+    return '\n'.join(diff)
+
+# --- STREAMLIT APP ---
+st.set_page_config(page_title="AI Workflow App", layout="wide")
+st.title("AI Assistant with Workflow (Streamlit Edition)")
+
+# Navigation
+page = st.sidebar.radio("Navigate", ["Home", "AI Workflow", "Semantic Search"])
+
+if page == "Home":
+    st.header("Welcome to the AI Assistant!")
+    st.markdown("""
+    - **Full AI Workflow:** Complete code analysis pipeline with explanation, refactoring, review, and testing (powered by Groq/Blackbox)
+    - **Semantic Search:** Ask natural language questions about your code and get intelligent answers
+    """)
+    st.info("Select a feature from the sidebar to get started.")
+
+elif page == "AI Workflow":
+    st.header("Full AI Workflow")
+    code_input = st.text_area("Paste your code here", height=200)
+    uploaded_file = st.file_uploader("Or upload a code file", type=["py", "js", "ts", "java", "cpp", "cs"])
     if uploaded_file:
         code_input = uploaded_file.read().decode("utf-8")
-    else:
-        code_input = st.text_area("Your Code", height=300, placeholder="Paste your code here...")
-
+        st.text_area("File content", code_input, height=200, key="file_content")
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        programming_language = st.selectbox("Programming Language", PROGRAMMING_LANGUAGES)
+    with col2:
+        skill_level = st.selectbox("Skill Level", SKILL_LEVELS)
+    with col3:
+        user_role = st.selectbox("Your Role", USER_ROLES)
+    with col4:
+        explanation_language = st.selectbox("Explanation Language", EXPLANATION_LANGUAGES)
     if code_input:
-        st.markdown(f"<b>Complexity:</b> {code_complexity(code_input)}", unsafe_allow_html=True)
-
-    if st.button("Run AI Workflow"):
+        st.caption(f"Complexity: {calculate_code_complexity(code_input)}")
+    if st.button("Run Workflow", type="primary"):
         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:
-                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?")
+            st.error("Please paste or upload your code.")
+        elif not code_matches_language(code_input, programming_language):
+            st.error(f"Language mismatch. Please check your code and language selection.")
+        else:
+            with st.spinner("Running AI Workflow..."):
+                # Simulate workflow steps
+                steps = [
+                    ("Explain", call_groq_api(f"Explain this {programming_language} code for a {skill_level} {user_role} in {explanation_language}:\n{code_input}")),
+                    ("Refactor", call_blackbox_agent(f"Refactor this {programming_language} code: {code_input}")),
+                    ("Review", call_groq_api(f"Review this {programming_language} code for errors and improvements: {code_input}")),
+                    ("ErrorDetection", call_groq_api(f"Find bugs in this {programming_language} code: {code_input}")),
+                    ("TestGeneration", call_groq_api(f"Generate tests for this {programming_language} code: {code_input}")),
+                ]
+                timeline = []
+                for step, output in steps:
+                    timeline.append({"step": step, "output": output})
+                st.success("Workflow complete!")
+                for t in timeline:
+                    st.subheader(t["step"])
+                    st.write(t["output"])
+                # Show code diff (Original vs Refactored)
+                st.subheader("Code Diff (Original vs Refactored)")
+                refactored_code = steps[1][1]  # Blackbox agent output
+                st.code(get_inline_diff(code_input, refactored_code), language=programming_language.lower())
+                # Download report
+                report = f"AI Workflow Report\nGenerated on: {datetime.datetime.now()}\nLanguage: {programming_language}\nSkill Level: {skill_level}\nRole: {user_role}\n\n"
+                for t in timeline:
+                    report += f"## {t['step']}\n{t['output']}\n\n---\n\n"
+                st.download_button("Download Report", report, file_name="ai_workflow_report.txt")
+
+elif page == "Semantic Search":
+    st.header("Semantic Search")
+    code_input = st.text_area("Paste your code here", height=200, key="sem_code")
+    uploaded_file = st.file_uploader("Or upload a code file", type=["py", "js", "ts", "java", "cpp", "cs"], key="sem_file")
+    if uploaded_file:
+        code_input = uploaded_file.read().decode("utf-8")
+        st.text_area("File content", code_input, height=200, key="sem_file_content")
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        programming_language = st.selectbox("Programming Language", PROGRAMMING_LANGUAGES, key="sem_lang")
+    with col2:
+        skill_level = st.selectbox("Skill Level", SKILL_LEVELS, key="sem_skill")
+    with col3:
+        user_role = st.selectbox("Your Role", USER_ROLES, key="sem_role")
+    with col4:
+        explanation_language = st.selectbox("Explanation Language", EXPLANATION_LANGUAGES, key="sem_expl")
+    question = st.text_input("Ask a question about your code")
+    st.caption("Example questions:")
+    st.write(", ".join(EXAMPLE_QUESTIONS))
     if st.button("Run Semantic Search"):
-        if not sem_code.strip() or not sem_q.strip():
-            st.warning("Code and question required.")
+        if not code_input.strip() or not question.strip():
+            st.error("Both code and question are required.")
+        elif not code_matches_language(code_input, programming_language):
+            st.error(f"Language mismatch. Please check your code and language selection.")
         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("---")
+            with st.spinner("Running Semantic Search..."):
+                answer = call_groq_api(f"{question}\n\nCode:\n{code_input}")
+                st.success("Answer:")
+                st.write(answer)