Upload merge_server.py

merge_server.py

@@ -0,0 +1,414 @@
+import os
+import pickle
+import torch
+import numpy as np
+import ast
+from flask import Flask, request, jsonify
+from transformers import AutoTokenizer, AutoModel
+
+# --- IMPORT ETHAN'S HYBRID ENGINE (Checker 1 & 2) ---
+from codesense.analyzer import analyze_code
+
+app = Flask(__name__)
+
+# --- CONFIG ---
+MODEL_FILE = 'NEW_BRAIN_MLP.pk2' 
+base_dir = os.path.dirname(os.path.abspath(__file__))
+model_path = os.path.join(base_dir, MODEL_FILE)
+
+print("⏳ Booting up CodeSense Triple-Checker System...")
+print("⏳ Loading Checker 1 & 2: AST Rule-Engine + CodeT5...")
+
+# --- LOAD YOUR SAFETY NET (Checker 3: CodeBERT + pk2) ---
+try:
+    print(f"📂 Loading Checker 3: CodeBERT Safety Net ({MODEL_FILE})...")
+    tokenizer = AutoTokenizer.from_pretrained("microsoft/codebert-base")
+    codebert = AutoModel.from_pretrained("microsoft/codebert-base")
+    
+    with open(model_path, 'rb') as f:
+        classifier = pickle.load(f)
+    print("✅ All 3 AI Brains Loaded! Server Ready on Port 5000.")
+except Exception as e:
+    print(f"❌ WARNING: Could not load Safety Net. {e}")
+    classifier = None
+
+def get_vector(code):
+    inputs = tokenizer(code, return_tensors="pt", truncation=True, max_length=512, padding=True)
+    with torch.no_grad():
+        outputs = codebert(**inputs)
+    return outputs.last_hidden_state[:, 0, :].numpy().flatten()
+
+
+# --- YOUR MAGIC VARIABLE EXTRACTOR & AST LOOP COUNTER ---
+class CodeAnalyzer(ast.NodeVisitor):
+    def __init__(self):
+        self.max_loop_depth = 0
+        self.current_loop_depth = 0
+        self.func_name = "optimized_function"
+        self.args_string = "data"
+        self.first_arg = "data"
+
+    def visit_FunctionDef(self, node):
+        self.func_name = node.name
+        arg_names = [arg.arg for arg in node.args.args]
+        if arg_names:
+            self.args_string = ", ".join(arg_names)
+            self.first_arg = arg_names[0]
+        self.generic_visit(node)
+        
+    def visit_For(self, node):
+        self.current_loop_depth += 1
+        if self.current_loop_depth > self.max_loop_depth:
+            self.max_loop_depth = self.current_loop_depth
+        self.generic_visit(node)
+        self.current_loop_depth -= 1
+
+    def visit_While(self, node):
+        self.current_loop_depth += 1
+        if self.current_loop_depth > self.max_loop_depth:
+            self.max_loop_depth = self.current_loop_depth
+        self.generic_visit(node)
+        self.current_loop_depth -= 1
+
+
+# --- API ROUTE ---
+@app.route('/predict', methods=['POST'])
+def predict():
+    data = request.json
+    code = data.get('code', '')
+    if not code: return jsonify({"error": "No code provided"}), 400
+    
+    try:
+        # 1. Extract your variables & Count Loops
+        analyzer = CodeAnalyzer()
+        try:
+            tree = ast.parse(code)
+            analyzer.visit(tree)
+            
+            # --- CALCULATE TIME COMPLEXITY USING AST ---
+            loop_depth = analyzer.max_loop_depth
+            if loop_depth == 0: dynamic_comp = "O(1) (No loops)"
+            elif loop_depth == 1: dynamic_comp = "O(n) (Linear)"
+            elif loop_depth == 2: dynamic_comp = "O(n^2) (Nested loops)"
+            else: dynamic_comp = f"O(n^{loop_depth}) (Deeply nested)"
+            
+        except Exception:
+            dynamic_comp = "Error parsing code structure"
+
+        # ==========================================
+        # 🛡️ THE TRIPLE-CHECKER LOGIC
+        # ==========================================
+        
+        # Run Ethan's Engine
+        analysis_result = analyze_code(code)
+        
+        algo = analysis_result.get("pattern", "Unknown")
+        ethan_summary = analysis_result.get("summary", "")
+        t5_raw_conf = analysis_result.get("ml_insights", {}).get("confidence", 0.0)
+        
+        final_conf = t5_raw_conf
+        safety_net_triggered = False
+
+        # Patterns that mean the first engine is slightly confused
+        GENERIC_PATTERNS = ["Unknown", "Nested Iterative", "Linear Iterative", "Recursive (Linear)", "Recursive (Exponential)"]
+
+        # If AST/CodeT5 is confused, trigger YOUR CodeBERT model!
+        if (algo in GENERIC_PATTERNS or t5_raw_conf < 0.90) and classifier is not None:
+            print(f"⚠️ Primary engine unsure (Confidence: {t5_raw_conf:.2f}). Triggering CodeBERT Safety Net...")
+            
+            try:
+                vector = get_vector(code)
+                bert_pred = classifier.predict([vector])[0]
+                
+                try:
+                    bert_probs = classifier.predict_proba([vector])[0]
+                    bert_conf = float(max(bert_probs))
+                except:
+                    bert_conf = 0.85 
+                
+                if bert_conf >= 0.80:
+                    algo = bert_pred
+                    final_conf = bert_conf
+                    safety_net_triggered = True
+                    print(f"🛡️ Safety Net Override Successful: {algo} ({bert_conf*100:.1f}%)")
+            except Exception as e:
+                print(f"Safety Net Error: {e}")
+
+        conf_percentage = (final_conf * 100) if final_conf else 100.0
+
+        # ==========================================
+        # 📚 YOUR FULL UI DICTIONARY 
+        # ==========================================
+        complexity_map = {
+            # --- SORTING ---
+            "Bubble Sort": {
+                "space": "O(1)",
+                "explanation": "⚠️ CRITICAL: Bubble Sort is inefficient (O(n^2)) for large datasets. Refactor to Quick Sort or Merge Sort (O(n log n)).",
+                "improvements": ["Added a 'swapped' flag to exit early if sorted.", "Shrink inner loop by 'i' each pass."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    n = len([FIRST_ARG])\n    for i in range(n):\n        swapped = False\n        for j in range(0, n - i - 1):\n            if [FIRST_ARG][j] > [FIRST_ARG][j + 1]:\n                [FIRST_ARG][j], [FIRST_ARG][j + 1] = [FIRST_ARG][j + 1], [FIRST_ARG][j]\n                swapped = True\n        if not swapped: break\n    return [FIRST_ARG]",
+                "recommended_name": "Quick Sort OR Merge Sort (O(n log n))",
+                "recommended_code": "# --- OPTION 1: QUICK SORT ---\nimport random\ndef [FUNC_NAME]_quicksort([ARGS]):\n    if len([FIRST_ARG]) <= 1: return [FIRST_ARG]\n    pivot = random.choice([FIRST_ARG])\n    L = [x for x in [FIRST_ARG] if x < pivot]\n    M = [x for x in [FIRST_ARG] if x == pivot]\n    R = [x for x in [FIRST_ARG] if x > pivot]\n    return [FUNC_NAME]_quicksort(L) + M + [FUNC_NAME]_quicksort(R)\n\n# --- OPTION 2: BUILT-IN SORT ---\ndef [FUNC_NAME]_timsort([ARGS]):\n    return sorted([FIRST_ARG])"
+            },
+            "Insertion Sort": {
+                "space": "O(1)",
+                "explanation": "⚠️ WARNING: Insertion Sort is slow (O(n^2)) for large lists. It is okay for small inputs (<50 items), but consider Quick Sort for scalability.",
+                "improvements": ["Your logic is correct for small datasets, but fails to scale.", "For >50 items, pivot to a divide-and-conquer approach."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    for i in range(1, len([FIRST_ARG])):\n        key = [FIRST_ARG][i]\n        j = i - 1\n        while j >= 0 and key < [FIRST_ARG][j]:\n            [FIRST_ARG][j + 1] = [FIRST_ARG][j]\n            j -= 1\n        [FIRST_ARG][j + 1] = key\n    return [FIRST_ARG]",
+                "recommended_name": "Quick Sort OR Merge Sort (O(n log n))",
+                "recommended_code": "# --- OPTION 1: QUICK SORT ---\ndef [FUNC_NAME]_quicksort([ARGS]):\n    if len([FIRST_ARG]) <= 1: return [FIRST_ARG]\n    pivot = [FIRST_ARG][len([FIRST_ARG]) // 2]\n    return [FUNC_NAME]_quicksort([x for x in [FIRST_ARG] if x < pivot]) + \\\n           [x for x in [FIRST_ARG] if x == pivot] + \\\n           [FUNC_NAME]_quicksort([x for x in [FIRST_ARG] if x > pivot])"
+            },
+            "Hash Map Lookup": {
+                "space": "O(n)",
+                "explanation": "✅ GOOD: Uses a dictionary (Hash Map) for instant O(1) lookups instead of repeatedly searching through a list. This drops the time complexity from O(n^2) down to a highly efficient O(n).",
+                "improvements": ["You are correctly using a dictionary to map elements.", "This trades a small amount of memory O(n) for a massive speedup O(1) per lookup."],
+                "optimized_code": "def [FUNC_NAME]([ARGS], target):\n    seen = {}\n    for i, val in enumerate([FIRST_ARG]):\n        needed = target - val\n        if needed in seen:\n            return [seen[needed], i]\n        seen[val] = i\n    return []"
+            },
+            "Selection Sort": {
+                "space": "O(1)",
+                "explanation": "⚠️ WARNING: Selection Sort is always O(n^2), even if the list is sorted. Switch to Insertion Sort (for small lists) or Merge Sort.",
+                "improvements": ["Avoid this algorithm entirely for production code.", "Replace with an algorithm that adapts to already-sorted data."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    for i in range(len([FIRST_ARG])):\n        min_idx = i\n        for j in range(i+1, len([FIRST_ARG])):\n            if [FIRST_ARG][j] < [FIRST_ARG][min_idx]:\n                min_idx = j\n        [FIRST_ARG][i], [FIRST_ARG][min_idx] = [FIRST_ARG][min_idx], [FIRST_ARG][i]\n    return [FIRST_ARG]",
+                "recommended_name": "Insertion Sort OR Merge Sort",
+                "recommended_code": "# --- OPTION 1: INSERTION SORT ---\ndef [FUNC_NAME]_insertion([ARGS]):\n    for i in range(1, len([FIRST_ARG])):\n        key = [FIRST_ARG][i]\n        j = i - 1\n        while j >= 0 and key < [FIRST_ARG][j]:\n            [FIRST_ARG][j + 1] = [FIRST_ARG][j]\n            j -= 1\n        [FIRST_ARG][j + 1] = key\n    return [FIRST_ARG]"
+            },
+            "Quick Sort": {
+                "space": "O(log n)",
+                "explanation": "✅ EXCELLENT: Quick Sort is a standard, efficient O(n log n) algorithm. Ensure you handle the worst-case pivot selection.",
+                "improvements": ["Ensure your pivot is chosen randomly instead of always picking the first or last element."],
+                "optimized_code": "import random\ndef [FUNC_NAME]([ARGS]):\n    if len([FIRST_ARG]) <= 1: return [FIRST_ARG]\n    pivot = random.choice([FIRST_ARG])\n    left = [x for x in [FIRST_ARG] if x < pivot]\n    middle = [x for x in [FIRST_ARG] if x == pivot]\n    right = [x for x in [FIRST_ARG] if x > pivot]\n    return [FUNC_NAME](left) + middle + [FUNC_NAME](right)"
+            },
+            "Merge Sort": {
+                "space": "O(n)",
+                "explanation": "✅ EXCELLENT: Merge Sort is stable and consistent O(n log n). Great for large datasets.",
+                "improvements": ["Your algorithm is optimal for time complexity.", "Be aware that Merge Sort uses O(n) extra memory."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    if len([FIRST_ARG]) > 1:\n        mid = len([FIRST_ARG]) // 2\n        L, R = [FIRST_ARG][:mid], [FIRST_ARG][mid:]\n        [FUNC_NAME](L)\n        [FUNC_NAME](R)\n        i = j = k = 0\n        while i < len(L) and j < len(R):\n            if L[i] < R[j]:\n                [FIRST_ARG][k] = L[i]\n                i += 1\n            else:\n                [FIRST_ARG][k] = R[j]\n                j += 1\n            k += 1\n        while i < len(L):\n            [FIRST_ARG][k] = L[i]\n            i, k = i + 1, k + 1\n        while j < len(R):\n            [FIRST_ARG][k] = R[j]\n            j, k = j + 1, k + 1\n    return [FIRST_ARG]"
+            },
+            "Heap Sort": {
+                "space": "O(1)",
+                "explanation": "✅ GOOD: Heap Sort is memory efficient (O(1) extra space) and fast (O(n log n)).",
+                "improvements": ["Use Python's built-in `heapq` library for C-level optimization."],
+                "optimized_code": "import heapq\ndef [FUNC_NAME]([ARGS]):\n    heapq.heapify([FIRST_ARG])\n    return [heapq.heappop([FIRST_ARG]) for _ in range(len([FIRST_ARG]))]"
+            },
+            "Counting Sort": {
+                "space": "O(n + k)",
+                "explanation": "✅ EFFICIENT: Very fast (O(n+k)) for integers with a small range. Not suitable for strings or large ranges.",
+                "improvements": ["Ensure your data strictly contains integers with a known maximum value."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    if not [FIRST_ARG]: return [FIRST_ARG]\n    max_val = max([FIRST_ARG])\n    count = [0] * (max_val + 1)\n    for num in [FIRST_ARG]: count[num] += 1\n    idx = 0\n    for i in range(len(count)):\n        while count[i] > 0:\n            [FIRST_ARG][idx] = i\n            idx += 1\n            count[i] -= 1\n    return [FIRST_ARG]"
+            },
+
+            # --- SEARCHING ---
+            "Linear Search": {
+                "space": "O(1)",
+                "explanation": "⚠️ INEFFICIENT: iterating through every item is O(n). If your data is sorted, switch to Binary Search (O(log n)) for a massive speedup.",
+                "improvements": ["Only checking items one by one requires O(n) time.", "If your data is sorted, use Binary Search."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    for i in range(len([FIRST_ARG])):\n        if [FIRST_ARG][i] == target: return i # Target must be passed\n    return -1",
+                "recommended_name": "Binary Search (O(log n))",
+                "recommended_code": "import bisect\ndef [FUNC_NAME]_binary([ARGS]):\n    # Assuming [FIRST_ARG] is sorted\n    idx = bisect.bisect_left([FIRST_ARG], target)\n    if idx < len([FIRST_ARG]) and [FIRST_ARG][idx] == target:\n        return idx\n    return -1"
+            },
+            "Binary Search": {
+                "space": "O(1)",
+                "explanation": "✅ PERFECT: Binary Search is the gold standard (O(log n)) for sorted arrays.",
+                "improvements": ["Ensure your array is sorted first.", "You can manually write it with a while loop, or use Python's built in `bisect` library."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    # Manual implementation\n    left, right = 0, len([FIRST_ARG]) - 1\n    while left <= right:\n        mid = (left + right) // 2\n        if [FIRST_ARG][mid] == target: return mid\n        elif [FIRST_ARG][mid] < target: left = mid + 1\n        else: right = mid - 1\n    return -1"
+            },
+            "Jump Search": {
+                "space": "O(1)",
+                "explanation": "✅ GOOD: Jump Search (O(√n)) is better than Linear Search, but Binary Search is still faster if random access is allowed.",
+                "improvements": ["If you are using standard lists, switch to Binary Search (O(log n))."],
+                "optimized_code": "import math\ndef [FUNC_NAME]([ARGS]):\n    n = len([FIRST_ARG])\n    step = int(math.sqrt(n))\n    prev = 0\n    while [FIRST_ARG][min(step, n)-1] < target:\n        prev = step\n        step += int(math.sqrt(n))\n        if prev >= n: return -1\n    while [FIRST_ARG][prev] < target:\n        prev += 1\n        if prev == min(step, n): return -1\n    if [FIRST_ARG][prev] == target: return prev\n    return -1",
+                "recommended_name": "Binary Search (O(log n))",
+                "recommended_code": "import bisect\ndef [FUNC_NAME]_binary([ARGS]):\n    idx = bisect.bisect_left([FIRST_ARG], target)\n    if idx < len([FIRST_ARG]) and [FIRST_ARG][idx] == target:\n        return idx\n    return -1"
+            },
+
+            # --- RECURSION, DP, & MATH ---
+            "Fibonacci Sequence": {
+                "space": "O(n)",
+                "explanation": "⚠️ RECURSION ALERT: Simple recursive Fibonacci is O(2^n) (Exponential). Refactor to use Dynamic Programming (Memoization) or an Iterative Loop to make it O(n).",
+                "improvements": ["Recursion causes stack overflow risks."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    if [FIRST_ARG] <= 0: return 0\n    if [FIRST_ARG] == 1: return 1\n    return [FUNC_NAME]([FIRST_ARG]-1) + [FUNC_NAME]([FIRST_ARG]-2)",
+                "recommended_name": "Iterative OR Memoized Fibonacci (O(n))",
+                "recommended_code": "# --- OPTION 1: ITERATIVE (O(1) Space) ---\ndef [FUNC_NAME]_iterative([ARGS]):\n    if [FIRST_ARG] <= 0: return 0\n    if [FIRST_ARG] == 1: return 1\n    a, b = 0, 1\n    for _ in range(2, [FIRST_ARG] + 1):\n        a, b = b, a + b\n    return b\n\n# --- OPTION 2: MEMOIZATION (Caching) ---\nfrom functools import lru_cache\n@lru_cache(maxsize=None)\ndef [FUNC_NAME]_memoized([ARGS]):\n    if [FIRST_ARG] <= 1: return [FIRST_ARG]\n    return [FUNC_NAME]_memoized([FIRST_ARG]-1) + [FUNC_NAME]_memoized([FIRST_ARG]-2)"
+            },
+            "Memoization": {
+                "space": "O(n)",
+                "explanation": "✅ EFFICIENT: You successfully applied Memoization (Top-Down DP) to prevent redundant calculations.",
+                "improvements": ["Caching results prevents the O(2^n) exponential blow-up of standard recursion."],
+                "optimized_code": "memo = {}\ndef [FUNC_NAME]([ARGS]):\n    if [FIRST_ARG] in memo: return memo[[FIRST_ARG]]\n    if [FIRST_ARG] <= 1: return [FIRST_ARG]\n    memo[[FIRST_ARG]] = [FUNC_NAME]([FIRST_ARG]-1) + [FUNC_NAME]([FIRST_ARG]-2)\n    return memo[[FIRST_ARG]]"
+            },
+            "Tabulation": {
+                "space": "O(n)",
+                "explanation": "✅ EFFICIENT: You successfully applied Tabulation (Bottom-Up DP) to prevent recursion stack overflow limits.",
+                "improvements": ["Iteratively building the table is memory safe and prevents RecursionError."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    if [FIRST_ARG] <= 0: return 0\n    dp = [0] * ([FIRST_ARG] + 1)\n    dp[1] = 1\n    for i in range(2, [FIRST_ARG] + 1):\n        dp[i] = dp[i-1] + dp[i-2]\n    return dp[[FIRST_ARG]]"
+            },
+            "Factorial (Recursive)": {
+                "space": "O(n)",
+                "explanation": "⚠️ STACK RISK: Recursive Factorial works, but large inputs will cause a `RecursionError`. Use an Iterative Loop for safety.",
+                "improvements": ["Use a `for` loop to accumulate the result instead of recursion.", "Better yet, use Python's built in `math.factorial()`."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    if [FIRST_ARG] == 1 or [FIRST_ARG] == 0: return 1\n    return [FIRST_ARG] * [FUNC_NAME]([FIRST_ARG] - 1)",
+                "recommended_name": "Iterative Factorial (O(n))",
+                "recommended_code": "import math\ndef [FUNC_NAME]_safe([ARGS]):\n    # Built-in math functions run in C and avoid RecursionErrors\n    return math.factorial([FIRST_ARG])"
+            },
+            "Factorial (Iterative)": {
+                "space": "O(1)",
+                "explanation": "✅ GOOD: Iterative Factorial is safe and efficient (O(n)).",
+                "improvements": ["Your logic is solid, but you can achieve even faster execution using the built-in math module."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    result = 1\n    for i in range(2, [FIRST_ARG] + 1):\n        result *= i\n    return result"
+            },
+            "Prime Check": {
+                "space": "O(1)",
+                "explanation": "✅ EFFICIENT: This O(√n) approach is much faster than checking all numbers up to N.",
+                "improvements": ["Ensure your loop stops at the square root of n.", "Handle edge cases for 1, 2, and 3 explicitly."],
+                "optimized_code": "import math\ndef [FUNC_NAME]([ARGS]):\n    if [FIRST_ARG] <= 1: return False\n    if [FIRST_ARG] in (2, 3): return True\n    if [FIRST_ARG] % 2 == 0 or [FIRST_ARG] % 3 == 0: return False\n    for i in range(5, int(math.sqrt([FIRST_ARG])) + 1, 6):\n        if [FIRST_ARG] % i == 0 or [FIRST_ARG] % (i + 2) == 0: return False\n    return True"
+            },
+            "GCD (Euclidean)": {
+                "space": "O(1)",
+                "explanation": "✅ PERFECT: Euclidean algorithm is the most efficient way to find GCD.",
+                "improvements": ["Use Python's built-in `math.gcd` for cleaner and slightly faster code."],
+                "optimized_code": "def [FUNC_NAME](a, b):\n    while b:\n        a, b = b, a % b\n    return abs(a)"
+            },
+            "Palindrome Check": {
+                "space": "O(1)",
+                "explanation": "✅ GOOD: O(n) is the optimal complexity for checking palindromes.",
+                "improvements": ["In Python, slicing is often faster than setting up a while loop with two pointers."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    return str([FIRST_ARG]) == str([FIRST_ARG])[::-1]"
+            },
+            "Armstrong Number": {
+                "space": "O(log n)",
+                "explanation": "✅ GOOD: Analyzing digits is O(log n), which is optimal.",
+                "improvements": ["Convert the number to a string to easily iterate over the digits."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    digits = str([FIRST_ARG])\n    power = len(digits)\n    return [FIRST_ARG] == sum(int(d)**power for d in digits)"
+            },
+
+            # --- GRAPHS, POINTERS, & DATA STRUCTURES ---
+            "Dijkstra's Algorithm": {
+                "space": "O(V)",
+                "explanation": "✅ INDUSTRY STANDARD: Best for finding shortest paths in weighted graphs.",
+                "improvements": ["Ensure you are using a Priority Queue (`heapq`) to achieve O(E log V) time complexity."],
+                "optimized_code": "import heapq\ndef [FUNC_NAME](graph, start):\n    distances = {node: float('inf') for node in graph}\n    distances[start] = 0\n    pq = [(0, start)]\n    while pq:\n        curr_dist, curr_node = heapq.heappop(pq)\n        if curr_dist > distances[curr_node]: continue\n        for neighbor, weight in graph[curr_node].items():\n            dist = curr_dist + weight\n            if dist < distances[neighbor]:\n                distances[neighbor] = dist\n                heapq.heappush(pq, (dist, neighbor))\n    return distances"
+            },
+            "Heap-Based Algorithm": {
+                "space": "O(N)",
+                "explanation": "✅ GOOD: Ideal for dynamically finding the top K elements (smallest/largest), scheduling tasks, or building priority queues without sorting the whole list.",
+                "improvements": ["Always use Python's built-in `heapq` module instead of manually sorting arrays with `.sort()`.", "Use `heapq.heapify()` to build your initial heap in O(N) time instead of pushing items one-by-one."],
+                "optimized_code": "import heapq\n\ndef [FUNC_NAME](data, k):\n    # O(N) time to build the heap in-place\n    heapq.heapify(data)\n    # Extract the k smallest elements efficiently\n    result = [heapq.heappop(data) for _ in range(k)]\n    return result"
+            },
+            "Breadth-First Search": {
+                "space": "O(V)",
+                "explanation": "✅ GOOD: Perfect for shortest paths in unweighted graphs or level-order traversal.",
+                "improvements": ["Always use `collections.deque` for the queue instead of a standard list."],
+                "optimized_code": "from collections import deque\ndef [FUNC_NAME](graph, start):\n    visited = set([start])\n    queue = deque([start])\n    result = []\n    while queue:\n        node = queue.popleft()\n        result.append(node)\n        for neighbor in graph[node]:\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append(neighbor)\n    return result"
+            },
+            "BFS (Graph)": {
+                "space": "O(V)",
+                "explanation": "✅ GOOD: Perfect for shortest paths in unweighted graphs or level-order traversal.",
+                "improvements": ["Always use `collections.deque` for the queue instead of a standard list."],
+                "optimized_code": "from collections import deque\ndef [FUNC_NAME](graph, start):\n    visited = set([start])\n    queue = deque([start])\n    result = []\n    while queue:\n        node = queue.popleft()\n        result.append(node)\n        for neighbor in graph[node]:\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append(neighbor)\n    return result"
+            },
+            "Depth-First Search": {
+                "space": "O(V)",
+                "explanation": "✅ GOOD: Standard for pathfinding puzzles, topological sorting, and cycle detection.",
+                "improvements": ["If recursion depth is a concern, switch to an iterative DFS using a stack."],
+                "optimized_code": "def [FUNC_NAME](graph, start, visited=None):\n    if visited is None: visited = set()\n    visited.add(start)\n    # Process node here\n    for neighbor in graph[start]:\n        if neighbor not in visited:\n            [FUNC_NAME](graph, neighbor, visited)\n    return visited"
+            },
+            "DFS (Graph)": {
+                "space": "O(V)",
+                "explanation": "✅ GOOD: Standard for pathfinding puzzles, topological sorting, and cycle detection.",
+                "improvements": ["If recursion depth is a concern, switch to an iterative DFS using a stack."],
+                "optimized_code": "def [FUNC_NAME](graph, start, visited=None):\n    if visited is None: visited = set()\n    visited.add(start)\n    # Process node here\n    for neighbor in graph[start]:\n        if neighbor not in visited:\n            [FUNC_NAME](graph, neighbor, visited)\n    return visited"
+            },
+            "Sliding Window": {
+                "space": "O(1)",
+                "explanation": "✅ EFFICIENT: Sliding window prevents duplicate work when analyzing subarrays.",
+                "improvements": ["Maintains a running sum/condition without needing nested O(n^2) loops."],
+                "optimized_code": "def [FUNC_NAME](arr, k):\n    current_sum = 0\n    left = 0\n    for right in range(len(arr)):\n        current_sum += arr[right]\n        if right - left + 1 > k:\n            current_sum -= arr[left]\n            left += 1\n    return current_sum"
+            },
+            "Two-Pointer Technique": {
+                "space": "O(1)",
+                "explanation": "✅ EFFICIENT: Two pointers walking towards each other saves incredible amounts of memory.",
+                "improvements": ["Much faster than nested O(n^2) loops when dealing with sorted arrays."],
+                "optimized_code": "def [FUNC_NAME](arr, target):\n    left, right = 0, len(arr) - 1\n    while left < right:\n        s = arr[left] + arr[right]\n        if s == target: return True\n        elif s < target: left += 1\n        else: right -= 1\n    return False"
+            },
+            "Binary Search Tree": {
+                "space": "O(n)",
+                "explanation": "ℹ️ INFO: Operations are O(log n) on average, but can degrade to O(n) if the tree is unbalanced. Consider an AVL Tree or Red-Black Tree for guaranteed performance.",
+                "improvements": ["Consider just using the built-in `dict` or `set` which are highly optimized Hash Tables in Python."],
+                "optimized_code": "class Node:\n    def __init__(self, key):\n        self.left, self.right, self.val = None, None, key\n\ndef [FUNC_NAME](root, key):\n    if root is None or root.val == key: return root\n    if root.val < key: return [FUNC_NAME](root.right, key)\n    return [FUNC_NAME](root.left, key)"
+            },
+            "Stack Operations": {
+                "space": "O(n)",
+                "explanation": "✅ OPTIMAL: Push/Pop operations are O(1).",
+                "improvements": ["Standard Python lists are perfect for stacks. Just ensure you only use `.append()` and `.pop()`."],
+                "optimized_code": "def [FUNC_NAME]():\n    stack = []\n    stack.append('item') # Push O(1)\n    item = stack.pop()   # Pop O(1)\n    return item"
+            },
+            "Queue (List)": {
+                "space": "O(n)",
+                "explanation": "⚠️ WARNING: Using `list.pop(0)` in Python is O(n). Use `collections.deque` for true O(1) queue operations.",
+                "improvements": ["Import 'deque' from the collections module.", "Use 'popleft()' instead of 'pop(0)' to achieve O(1) constant time."],
+                "optimized_code": "def [FUNC_NAME]([ARGS]):\n    # Using list.pop(0) causes O(n) memory shifts\n    queue = list([FIRST_ARG])\n    queue.append('new_item')\n    item = queue.pop(0) \n    return item",
+                "recommended_name": "Collections.deque (True O(1) Queue)",
+                "recommended_code": "from collections import deque\ndef [FUNC_NAME]_optimized([ARGS]):\n    queue = deque([FIRST_ARG])\n    queue.append('new_item')\n    # queue.popleft() is now O(1) instead of O(n)\n    item = queue.popleft()\n    return queue"
+            },
+            "Linked List (Singly)": {
+                "space": "O(n)",
+                "explanation": "ℹ️ INFO: Insertions are O(1) if you have the pointer, but searching is O(n).",
+                "improvements": ["Linked lists are rarely used in standard Python because standard lists are dynamic arrays."],
+                "optimized_code": "class Node:\n    def __init__(self, data):\n        self.data = data\n        self.next = None\n\nclass LinkedList:\n    def __init__(self):\n        self.head = None\n    def print_list(self):\n        temp = self.head\n        while temp:\n            print(temp.data)\n            temp = temp.next"
+            },
+            "Linked List (Doubly)": {
+                "space": "O(n)",
+                "explanation": "✅ FLEXIBLE: Doubly Linked Lists allow bidirectional traversal, at the cost of slightly more memory.",
+                "improvements": ["Python's built-in `collections.deque` is actually a Doubly Linked List under the hood! Use it for max performance."],
+                "optimized_code": "from collections import deque\n# deque is an optimized doubly linked list\ndef [FUNC_NAME]():\n    dll = deque(['a', 'b', 'c'])\n    dll.append('d')      # Add to right\n    dll.appendleft('z')  # Add to left\n    return dll"
+            }
+        }
+        
+        # 4. Fallback Data
+        default_data = {
+            "space": "O(N)",
+            "explanation": f"CodeSense Engine Analysis: {ethan_summary}",
+            "improvements": ["Analysis pending for this algorithm."],
+            "optimized_code": "# Recognized Pattern. Specific optimization currently unavailable."
+        }
+        
+        # Handle matching names (e.g. "Linear Search" vs "Linear Iterative" from different models)
+        if algo == "Linear Iterative" and "Linear Search" in complexity_map:
+            algo_key = "Linear Search"
+        elif algo == "Recursive (Exponential)" and "Factorial (Recursive)" in complexity_map:
+            algo_key = "Fibonacci Sequence" # General fallback for exponential recursion
+        else:
+            algo_key = algo
+            
+        result_data = complexity_map.get(algo_key, default_data)
+        
+        # --- YOUR MAGIC VARIABLE REPLACEMENT FOR BOTH CODES ---
+        # 1. Format Optimized Code
+        opt_code = result_data.get("optimized_code", "").replace("[FUNC_NAME]", analyzer.func_name).replace("[ARGS]", analyzer.args_string).replace("[FIRST_ARG]", analyzer.first_arg)
+        
+        # 2. Format Recommended Code (if it exists)
+        rec_code = result_data.get("recommended_code", "")
+        if rec_code:
+            rec_code = rec_code.replace("[FUNC_NAME]", analyzer.func_name).replace("[ARGS]", analyzer.args_string).replace("[FIRST_ARG]", analyzer.first_arg)
+        rec_name = result_data.get("recommended_name", "")
+
+        # 5. Send EVERYTHING back to VS Code
+        return jsonify({
+            "algorithm": algo,
+            "confidence": f"{conf_percentage:.1f}%",
+            "dynamic_complexity": dynamic_comp,
+            "space_complexity": result_data.get("space", "O(N)"),
+            "explanation": result_data.get("explanation", ""),
+            "improvements": result_data.get("improvements", []),
+            "optimized_code": opt_code,
+            "recommended_name": rec_name,
+            "recommended_code": rec_code,
+            "safety_net_used": safety_net_triggered
+        })
+        
+    except Exception as e:
+        import traceback
+        print(traceback.format_exc())
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860)