Update app.py

app.py

@@ -45,6 +45,9 @@ class CodeGenius:
         # Initialize embedding model for semantic search
         self.init_embedding_model()
         
+    # Feature flags (env driven)
+    self.use_local_llm = os.getenv("USE_LOCAL_LLM", "0") == "1"
+        
     def load_programming_data(self) -> Dict:
         """Load programming knowledge from JSON file"""
         try:
@@ -198,12 +201,13 @@ class CodeGenius:
         """Load AI model for advanced queries"""
         if self.model_loaded:
             return True
-            
-        if TRANSFORMERS_AVAILABLE:
+
+        # Only attempt heavy model if explicitly enabled
+        if TRANSFORMERS_AVAILABLE and self.use_local_llm:
             try:
                 # Use a code-specific model
                 model_name = "bigcode/starcoder2-7b"
-                
+
                 self.tokenizer = AutoTokenizer.from_pretrained(model_name)
                 self.model = AutoModelForCausalLM.from_pretrained(
                     model_name,
@@ -211,11 +215,11 @@ class CodeGenius:
                     device_map="auto" if torch.cuda.is_available() else None,
                     low_cpu_mem_usage=True
                 )
-                
+
                 # Add pad token if not present
                 if self.tokenizer.pad_token is None:
                     self.tokenizer.pad_token = self.tokenizer.eos_token
-                
+
                 self.generator = pipeline(
                     "text-generation",
                     model=self.model,
@@ -223,16 +227,17 @@ class CodeGenius:
                     device=0 if torch.cuda.is_available() else -1,
                     return_full_text=False
                 )
-                
+
                 self.model_loaded = True
                 print("✅ AI model loaded successfully!")
                 return True
-                
+
             except Exception as e:
                 print(f"⚠️ Could not load AI model: {str(e)}")
                 return False
         else:
-            print("🔧 Install transformers and torch for AI features")
+            if not TRANSFORMERS_AVAILABLE and self.use_local_llm:
+                print("🔧 Install transformers and torch for AI features")
             return False
     
     def generate_ai_response(self, query: str, context: str = "", code: str = "") -> str:
@@ -312,14 +317,161 @@ Provide the best solution with explanation and consider edge cases."""
         """Generate detailed error explanation and solution"""
         common_errors = lang_data.get('common_errors', [])
     
+        bullets = ", ".join([e.get('name', 'Unknown') for e in common_errors[:5]]) or "syntax and runtime issues"
+        steps = [
+            "Reproduce the error and capture the full traceback/message",
+            "Locate the failing line and inspect variables/inputs",
+            "Minimize to a small reproducible example",
+            "Apply a fix, then add/adjust a test to prevent regressions",
+        ]
+        suggestions = [f"{e.get('name', 'Error')}: {e.get('solution', '')}" for e in common_errors[:5]]
         response = (
-            f"Let me help you debug this {lang} code. Here's a systematic approach:\n\n"
-            "**Error Analysis:**\n"
-            f"First, let's identify the error type and root cause. Common {lang} errors include:\n"
-            f"{', '.join([e.get('name', 'Unknown') for e in common_errors[:3]])}\n\n"
-            "**Code Inspection:**\n"
-            "For the provided code:\n"
-            f"```{lang}\n"
-            f"{code if code else '# No code provided'}\n"
-            "```\n"
-        )
+            f"Debugging {lang}:\n"
+            f"Common issues: {bullets}.\n\n"
+            f"Code (context):\n{(code or '# no code provided').strip()}\n\n"
+            f"Steps:\n- " + "\n- ".join(steps) + "\n\n"
+            + ("Hints:\n- " + "\n- ".join(suggestions) if suggestions else "")
+        )
+        return response
+
+    def generate_optimization_response(self, lang: str, lang_data: dict, code: str) -> str:
+        tips = lang_data.get('optimization', [])
+        generic = [
+            "Profile first; optimize hot paths, not guesses",
+            "Prefer algorithms/data structures with better complexity",
+            "Avoid unnecessary allocations and copies",
+            "Cache expensive results where safe",
+        ]
+        body = (
+            f"Performance tips for {lang}:\n- " + "\n- ".join(tips + generic[: max(0, 4 - len(tips))]) +
+            (f"\n\nCode (context):\n{code.strip()}" if code else "")
+        )
+        return body
+
+    def generate_explanation_response(self, lang: str, lang_data: dict, code: str) -> str:
+        if not code:
+            return (
+                f"Explain {lang} code: provide the snippet for a targeted walkthrough.\n"
+                f"Meanwhile, key {lang} concepts: paradigms={', '.join(lang_data.get('paradigm', []))}, typing={lang_data.get('typing', 'n/a')}."
+            )
+        outline = [
+            "High-level: What does this code do?",
+            "Inputs/outputs: parameters, return values, side effects",
+            "Control flow: loops, branches, error handling",
+            "Data structures and complexity",
+        ]
+        return (
+            f"Explanation ({lang}):\n"
+            f"Code:\n{code.strip()}\n\n"
+            f"Consider:\n- " + "\n- ".join(outline)
+        )
+
+    def generate_code_response(self, lang: str, lang_data: dict, query: str) -> str:
+        # Provide a minimal idiomatic template per language
+        templates = {
+            'python': (
+                "# minimal CLI template\n"
+                "import sys\n\n"
+                "def main(argv: list[str]) -> int:\n"
+                "    # TODO: implement\n"
+                "    print('Hello from CodeGenius')\n"
+                "    return 0\n\n"
+                "if __name__ == '__main__':\n"
+                "    raise SystemExit(main(sys.argv[1:]))\n"
+            ),
+            'javascript': (
+                "// minimal Node.js module template\n"
+                "export function main(args = []) {\n"
+                "  console.log('Hello from CodeGenius');\n"
+                "}\n"
+            ),
+            'java': (
+                "// minimal Java app template\n"
+                "public class App {\n"
+                "  public static void main(String[] args) {\n"
+                "    System.out.println(\"Hello from CodeGenius\");\n"
+                "  }\n"
+                "}\n"
+            )
+        }
+        key = lang.lower()
+        snippet = templates.get(key, "// Provide more detail to generate specific code.")
+        return f"Generated starter for {lang}:\n{snippet}"
+
+    def generate_general_lang_response(self, lang: str, lang_data: dict, query: str) -> str:
+        paradigms = ', '.join(lang_data.get('paradigm', []))
+        use_cases = ', '.join(lang_data.get('use_cases', []))
+        typing = lang_data.get('typing', 'n/a')
+        pitfalls = ', '.join([e.get('name', '') for e in lang_data.get('common_errors', [])[:5]])
+        return (
+            f"{lang.capitalize()} overview: paradigms={paradigms}; typing={typing}; typical uses={use_cases}.\n"
+            f"Watch for: {pitfalls}.\n"
+            f"Query: {query}"
+        )
+
+    def generate_general_programming_response(self, query: str, context: str, code: str) -> str:
+        parts = []
+        if context:
+            parts.append(f"Relevant knowledge: {context}")
+        if code:
+            parts.append(f"Code context:\n{code.strip()}")
+        parts.append(
+            "Approach: clarify requirements, choose data structures, write small tests, implement incrementally, and profile if performance matters."
+        )
+        return f"Answering: {query}\n" + "\n\n".join(parts)
+
+    def answer(self, query: str, code: str = "") -> str:
+        """Top-level entry: perform semantic search, then answer."""
+        # Build context from semantic search
+        top = self.semantic_search(query, top_k=3)
+        context_str = " | ".join([t['item']['content'] for t in top]) if top else ""
+        # Use template or local LLM if enabled
+        return self.generate_ai_response(query, context_str, code)
+
+
+# -------- Simple UI / Entrypoint --------
+def _build_gradio_ui(genius: CodeGenius):
+    with gr.Blocks(title="CodeGenius") as demo:
+        gr.Markdown("# CodeGenius\nAn AI-powered programming helper (lightweight mode by default).")
+        chatbot = gr.Chatbot(height=350)
+        with gr.Row():
+            msg = gr.Textbox(label="Ask a question", scale=3)
+        code_in = gr.Textbox(label="Optional code context", lines=8)
+        clear = gr.Button("Clear")
+
+        state = gr.State([])
+
+        def respond(user_message, chat_history, code_text):
+            if not user_message:
+                return chat_history or [], chat_history or []
+            reply = genius.answer(user_message, code_text or "")
+            chat_history = (chat_history or []) + [[user_message, reply]]
+            return chat_history, chat_history
+
+        msg.submit(respond, [msg, chatbot, code_in], [chatbot, chatbot])
+        clear.click(lambda: ([], []), None, [chatbot, chatbot], queue=False)
+    return demo
+
+
+def main():
+    genius = CodeGenius()
+    if os.getenv("RUN_UI", "0") == "1":
+        demo = _build_gradio_ui(genius)
+        demo.launch(server_name="127.0.0.1", server_port=int(os.getenv("PORT", "7860")))
+        return
+    # CLI mode
+    print("CodeGenius (CLI). Type 'exit' to quit.")
+    while True:
+        try:
+            q = input("You> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+        if q.lower() in {"exit", "quit"}:
+            break
+        ans = genius.answer(q)
+        print(f"Bot> {ans}\n")
+
+
+if __name__ == "__main__":
+    main()