improved additional instructions

Author: cyclotruc

app.py

@@ -62,11 +62,19 @@ async def home(request: Request):
 
 
 @app.post("/", response_class=HTMLResponse) 
-async def generate_dockerfile(request: Request, repo_url: str = Form(...)):
+async def generate_dockerfile(
+    request: Request, 
+    repo_url: str = Form(...),
+    additional_instructions_hidden: str = Form("")
+):
     """Redirect to streaming page for Dockerfile generation."""
-    # Store the repo URL in a session (simple in-memory for demo)
+    # Store the repo URL and additional instructions in a session (simple in-memory for demo)
     session_id = str(hash(repo_url + str(asyncio.get_event_loop().time())))
-    sessions[session_id] = {"repo_url": repo_url, "status": "pending"}
+    sessions[session_id] = {
+        "repo_url": repo_url,
+        "additional_instructions": additional_instructions_hidden.strip() if additional_instructions_hidden else "",
+        "status": "pending"
+    }
 
     # Redirect to streaming page
     return templates.TemplateResponse("index.jinja", {
@@ -94,10 +102,11 @@ async def websocket_endpoint(websocket: WebSocket, session_id: str):
             return
 
         repo_url = sessions[session_id]["repo_url"]
+        additional_instructions = sessions[session_id].get("additional_instructions", "")
 
         # Step 1: Clone repository
         await websocket.send_text(json.dumps({
-            "type": "status",
+            "type": "status", 
             "content": f"🔄 Cloning repository: {repo_url}"
         }))
 
@@ -136,7 +145,8 @@ async def websocket_endpoint(websocket: WebSocket, session_id: str):
             gitingest_tree=ingest_result['tree'], 
             gitingest_content=ingest_result['content'],
             project_name=clone_result['repo_name'],
-            websocket=websocket  # Pass WebSocket for streaming
+            websocket=websocket,  # Pass WebSocket for streaming
+            additional_instructions=additional_instructions
         )
 
         if not container_result["success"]:
@@ -174,10 +184,21 @@ async def websocket_endpoint(websocket: WebSocket, session_id: str):
     except WebSocketDisconnect:
         print(f"WebSocket disconnected for session {session_id}")
     except Exception as e:
-        await websocket.send_text(json.dumps({
-            "type": "error",
-            "content": f"Unexpected error: {str(e)}"
-        }))
+        print(f"Error in WebSocket endpoint: {e}")
+        try:
+            await websocket.send_text(json.dumps({
+                "type": "error",
+                "content": f"Unexpected error: {str(e)}"
+            }))
+        except Exception as send_error:
+            print(f"Could not send error message, WebSocket likely closed: {send_error}")
+    finally:
+        # Clean up session data
+        try:
+            if session_id in sessions:
+                sessions[session_id]["status"] = "disconnected"
+        except:
+            pass
 
 
 @app.get("/health")

tools/create_container.py

@@ -88,8 +88,9 @@ async def create_container_tool(
 }}"""
 
         # Make API call to generate Dockerfile with streaming
-        await _emit_ws_message(websocket, "status", "🐳 Generating Dockerfile...")
-        print("🐳 Generating Dockerfile... (streaming response)\n")
+        websocket_active = await _emit_ws_message(websocket, "status", "🐳 Generating Dockerfile...")
+        if websocket_active:
+            print("🐳 Generating Dockerfile... (streaming response)\n")
 
         response = await client.chat.completions.create(
             model="gpt-4o-mini",  # Using GPT-4 for better code generation
@@ -110,7 +111,8 @@ async def create_container_tool(
 
         # Collect the streaming response and print in real-time
         dockerfile_response = ""
-        await _emit_ws_message(websocket, "stream_start", "Starting generation...")
+        if websocket_active:
+            websocket_active = await _emit_ws_message(websocket, "stream_start", "Starting generation...")
         print("📝 Response:")
         print("-" * 50)
 
@@ -119,12 +121,14 @@ async def create_container_tool(
                 content = chunk.choices[0].delta.content
                 print(content, end="", flush=True)
                 dockerfile_response += content
-                # Emit each chunk to WebSocket clients
-                await _emit_ws_message(websocket, "chunk", content)
+                # Only emit chunks if WebSocket is still active
+                if websocket_active:
+                    websocket_active = await _emit_ws_message(websocket, "chunk", content)
 
         print("\n" + "-" * 50)
         print("✅ Generation complete!\n")
-        await _emit_ws_message(websocket, "status", "✅ Generation complete!")
+        if websocket_active:
+            await _emit_ws_message(websocket, "status", "✅ Generation complete!")
 
         # Try to parse as JSON, fallback to plain text if needed
         try:
@@ -197,12 +201,20 @@ async def create_container_tool(
             "error": str(e),
             "project_name": project_name or "unknown-project"
         }
-        await _emit_ws_message(websocket, "error", str(e))
+        # Only send error message if WebSocket might still be active
+        try:
+            await _emit_ws_message(websocket, "error", str(e))
+        except:
+            # WebSocket is definitely closed, just log the error
+            print(f"Could not send error to WebSocket: {e}")
         return error_result
 
 
-async def _emit_ws_message(websocket: Optional[Any], message_type: str, content: str) -> None:
-    """Helper function to emit WebSocket messages safely."""
+async def _emit_ws_message(websocket: Optional[Any], message_type: str, content: str) -> bool:
+    """
+    Helper function to emit WebSocket messages safely.
+    Returns True if message was sent successfully, False if WebSocket is closed or error occurred.
+    """
     if websocket is not None:
         try:
             message = {
@@ -211,8 +223,12 @@ async def _emit_ws_message(websocket: Optional[Any], message_type: str, content:
                 "timestamp": asyncio.get_event_loop().time()
             }
             await websocket.send_text(json.dumps(message))
+            return True
         except Exception as e:
-            print(f"WebSocket error: {e}")
+            # WebSocket is likely closed, stop trying to send messages
+            print(f"WebSocket closed or error occurred: {e}")
+            return False
+    return False
 
 
 def run_create_container(