feat: Add language/framework optional inputs + context window control

CHANGES:
- Language and Framework now optional text inputs (empty = AI decides)
- Temperature default changed to 0.5 (more deterministic)
- Added Context Window slider (1000-8000 tokens, default 4000)
- Applied to both Single Model and Multi-Model Comparison tabs
- Updated examples with new parameters

UX IMPROVEMENTS:
- Users can now leave language/framework empty for AI auto-detection
- More precise control over response length via context window
- Better default temperature (0.5 vs 0.7) for production code

app.py

@@ -247,24 +247,38 @@ def generate_code_with_model(prompt: str, model_name: str, temperature: float =
         "tokens_per_sec": tokens_per_sec
     }
 
-def single_model_generation(prompt: str, model: str, temperature: float, language: str):
+def single_model_generation(prompt: str, model: str, temperature: float, language: str, framework: str, context_window: int):
     """Generate code with selected model"""
 
     if not prompt.strip():
         return "Please enter a project description."
 
-    enhanced_prompt = f"Generate {language} code for the following project:\n\n{prompt}"
+    # Build enhanced prompt with language/framework if specified
+    enhanced_prompt = prompt
+    if language.strip():
+        enhanced_prompt = f"Generate {language} code"
+        if framework.strip():
+            enhanced_prompt += f" using {framework}"
+        enhanced_prompt += f" for the following project:\n\n{prompt}"
+
+    # Add context window info to prompt
+    enhanced_prompt += f"\n\nNote: Keep response within {context_window} tokens."
 
     result = generate_code_with_model(enhanced_prompt, model, temperature)
 
+    lang_info = f"{language}" if language.strip() else "Auto-detected"
+    if framework.strip():
+        lang_info += f" + {framework}"
+
     output = f"""# Generated Code: {model}
 
 **Generation Time:** {result['elapsed_time']:.2f}s
-**Language:** {language}
+**Language/Framework:** {lang_info}
 **Lines of Code:** {result['loc']}
 **Tokens:** {result['input_tokens']} in → {result['output_tokens']} out
 **Speed:** {result['tokens_per_sec']:.0f} tokens/sec
 **Cost:** ${result['cost']:.4f}
+**Context Window:** {context_window} tokens
 
 ---
 
@@ -273,18 +287,26 @@ def single_model_generation(prompt: str, model: str, temperature: float, languag
 
     return output
 
-def multi_model_comparison(prompt: str, language: str):
+def multi_model_comparison(prompt: str, language: str, framework: str, temperature: float, context_window: int):
     """Compare all models on same prompt"""
 
     if not prompt.strip():
         return pd.DataFrame(), "Please enter a project description."
 
-    enhanced_prompt = f"Generate {language} code for: {prompt}"
+    # Build enhanced prompt with language/framework if specified
+    enhanced_prompt = prompt
+    if language.strip():
+        enhanced_prompt = f"Generate {language} code"
+        if framework.strip():
+            enhanced_prompt += f" using {framework}"
+        enhanced_prompt += f" for: {prompt}"
+
+    enhanced_prompt += f"\n\nNote: Keep response within {context_window} tokens."
 
     results = []
 
     for model_name in MODEL_CONFIGS.keys():
-        result = generate_code_with_model(enhanced_prompt, model_name, 0.7)
+        result = generate_code_with_model(enhanced_prompt, model_name, temperature)
 
         results.append({
             "Model": model_name,
@@ -344,24 +366,37 @@ with gr.Blocks(
                     value="Create a simple TODO list API with CRUD operations using REST principles."
                 )
 
+                model_select = gr.Dropdown(
+                    choices=list(MODEL_CONFIGS.keys()),
+                    value="Claude Sonnet 4.5 💎",
+                    label="AI Model",
+                    info="Select the model to generate code"
+                )
+
                 with gr.Row():
-                    model_select = gr.Dropdown(
-                        choices=list(MODEL_CONFIGS.keys()),
-                        value="Claude Sonnet 4.5",
-                        label="AI Model",
-                        info="Select the model to generate code"
+                    language_input = gr.Textbox(
+                        label="Language (Optional)",
+                        placeholder="e.g., Rust, Python, TypeScript, Go, Java - Leave empty for AI to decide",
+                        value=""
                     )
-                    language_select = gr.Radio(
-                        choices=["Rust", "Python", "TypeScript", "Go", "Java"],
-                        value="Python",
-                        label="Language"
+                    framework_input = gr.Textbox(
+                        label="Framework (Optional)",
+                        placeholder="e.g., Axum, FastAPI, Express, Django - Leave empty for AI to decide",
+                        value=""
                     )
 
-                temp_slider = gr.Slider(
-                    0.0, 1.0, 0.7,
-                    label="Temperature",
-                    info="Higher = more creative, Lower = more deterministic"
-                )
+                with gr.Row():
+                    temp_slider = gr.Slider(
+                        0.0, 1.0, 0.5,
+                        label="Temperature",
+                        info="Higher = more creative, Lower = more deterministic"
+                    )
+                    context_slider = gr.Slider(
+                        1000, 8000, 4000,
+                        step=500,
+                        label="Context Window (tokens)",
+                        info="Maximum tokens in response"
+                    )
 
                 generate_btn = gr.Button("Generate Code", variant="primary", size="lg")
 
@@ -373,17 +408,17 @@ with gr.Blocks(
 
         generate_btn.click(
             single_model_generation,
-            inputs=[prompt_input, model_select, temp_slider, language_select],
+            inputs=[prompt_input, model_select, temp_slider, language_input, framework_input, context_slider],
             outputs=output_single
         )
 
         gr.Examples(
             examples=[
-                ["Create a REST API for a blog with users and posts", "Claude Sonnet 4.5", 0.7, "Rust"],
-                ["Build a CLI tool for file encryption using AES-256", "GPT-4o", 0.5, "Python"],
-                ["Implement a rate limiter middleware for web APIs", "Qwen2.5-72B", 0.7, "TypeScript"],
+                ["Create a REST API for a blog with users and posts", "Claude Sonnet 4.5 💎", 0.5, "Rust", "Axum", 4000],
+                ["Build a CLI tool for file encryption using AES-256", "GPT-4o 💎", 0.5, "Python", "Click", 3000],
+                ["Implement a rate limiter middleware for web APIs", "Llama 3.3 70B (Groq) 🚀", 0.5, "TypeScript", "Express", 4000],
             ],
-            inputs=[prompt_input, model_select, temp_slider, language_select]
+            inputs=[prompt_input, model_select, temp_slider, language_input, framework_input, context_slider]
         )
 
     with gr.Tab("⚡ Multi-Model Comparison"):
@@ -398,11 +433,30 @@ with gr.Blocks(
                     value="Create a minimal REST API for a TODO list with create, read, update, delete operations."
                 )
 
-                language_compare = gr.Radio(
-                    choices=["Rust", "Python", "TypeScript", "Go"],
-                    value="Python",
-                    label="Language"
-                )
+                with gr.Row():
+                    language_compare = gr.Textbox(
+                        label="Language (Optional)",
+                        placeholder="e.g., Python, Rust, TypeScript - Leave empty for AI to decide",
+                        value=""
+                    )
+                    framework_compare = gr.Textbox(
+                        label="Framework (Optional)",
+                        placeholder="e.g., FastAPI, Axum, Express - Leave empty for AI to decide",
+                        value=""
+                    )
+
+                with gr.Row():
+                    temp_compare = gr.Slider(
+                        0.0, 1.0, 0.5,
+                        label="Temperature",
+                        info="Higher = more creative, Lower = more deterministic"
+                    )
+                    context_compare = gr.Slider(
+                        1000, 8000, 4000,
+                        step=500,
+                        label="Context Window (tokens)",
+                        info="Maximum tokens in response"
+                    )
 
                 compare_btn = gr.Button("Compare All Models", variant="primary", size="lg")
 
@@ -415,7 +469,7 @@ with gr.Blocks(
 
         compare_btn.click(
             multi_model_comparison,
-            inputs=[prompt_compare, language_compare],
+            inputs=[prompt_compare, language_compare, framework_compare, temp_compare, context_compare],
             outputs=[comparison_table, winner_msg]
         )