added all of files via drag n drop

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+SDLC_Workflow_Graph_Diagram.png filter=lfs diff=lfs merge=lfs -text

SDLC.py

@@ -0,0 +1,1301 @@
+# newSDLC.py
+import os
+import sys
+import shutil
+from typing import List, Union, Dict, Annotated, Any
+from typing_extensions import TypedDict
+from pydantic import BaseModel, Field
+from langchain.schema import AIMessage, HumanMessage
+from langchain_core.language_models.base import BaseLanguageModel # Correct import path
+from langchain_groq import ChatGroq
+from langchain_openai import ChatOpenAI
+# Add imports for other potential providers if needed
+# from langchain_google_genai import ChatGoogleGenerativeAI
+# from langchain_anthropic import ChatAnthropic
+from tavily import TavilyClient
+from dotenv import load_dotenv
+import operator
+import logging
+import ast
+import time
+from plantuml import PlantUML
+from functools import wraps
+from tenacity import retry, stop_after_attempt, wait_exponential, wait_fixed, retry_if_exception_type
+
+# --- Basic logging setup ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# --- Load Environment Variables ---
+# Keep load_dotenv() in case some functions still rely on other env vars,
+# but LLM/Tavily keys will now come from function args.
+load_dotenv()
+
+# --- REMOVED LLM / Tavily Initialization Block ---
+# GLOBAL_LLM, OPENAI_LLM, tavily_client will be initialized dynamically
+
+# --- Pydantic Models ---
+# (Keep all Pydantic models as they were)
+class DiagramSelection(BaseModel):
+    diagram_types: List[str] = Field(..., description="List of 5 selected UML/DFD diagram types")
+    justifications: List[str] = Field(..., description="Brief justifications for each diagram type")
+class PlantUMLCode(BaseModel):
+    diagram_type: str = Field(..., description="Type of UML/DFD diagram")
+    code: str = Field(..., description="PlantUML code for the diagram")
+class CodeFile(BaseModel):
+    filename: str = Field(..., description="Name of the file, including path relative to project root")
+    content: str = Field(..., description="Full content of the file")
+class GeneratedCode(BaseModel):
+    files: List[CodeFile] = Field(..., description="List of all files in the project")
+    instructions: str = Field(..., description="Beginner-friendly setup and run instructions")
+class TestCase(BaseModel):
+    description: str = Field(..., description="Description of the test case")
+    input_data: dict = Field(..., description="Fake input data, must be non-empty")
+    expected_output: dict = Field(..., description="Expected fake output, must be non-empty")
+class TestCases(BaseModel):
+    test_cases: List[TestCase] = Field(..., description="List of test cases")
+
+# --- Main State Definition ---
+class MainState(TypedDict, total=False):
+    # --- ADDED instance storage ---
+    llm_instance: BaseLanguageModel | None # Store the initialized LLM
+    tavily_instance: TavilyClient | None # Store the initialized Tavily client
+    # --- END ADDED ---
+
+    # Core conversation history
+    messages: Annotated[List[Union[HumanMessage, AIMessage]], lambda x, y: (x or []) + (y or [])]
+
+    # Project definition
+    project_folder: str # Base name/relative path used for saving files
+    project: str
+    category: str
+    subcategory: str
+    coding_language: str
+
+    # User Input Cycle State
+    user_input_questions: List[str]
+    user_input_answers: List[str]
+    user_input_iteration: int
+    user_input_min_iterations: int
+    user_input_done: bool
+
+    # Core Artifacts
+    user_query_with_qa: str
+    refined_prompt: str
+    final_user_story: str
+    final_product_review: str
+    final_design_document: str
+    final_uml_codes: List[PlantUMLCode]
+    final_code_files: List[CodeFile]
+    final_code_review: str
+    final_security_issues: str
+    final_test_code_files: List[CodeFile]
+    final_quality_analysis: str
+    final_deployment_process: str
+
+    # File Paths
+    final_user_story_path: str
+    final_product_review_path: str
+    final_design_document_path: str
+    final_uml_diagram_folder: str
+    final_uml_png_paths: List[str]
+    final_review_security_folder: str
+    review_code_snapshot_folder: str
+    final_testing_folder: str
+    testing_passed_code_folder: str
+    final_quality_analysis_path: str
+    final_code_folder: str
+    final_deployment_path: str
+
+    # Intermediate States
+    user_story_current: str; user_story_feedback: str; user_story_human_feedback: str; user_story_done: bool;
+    product_review_current: str; product_review_feedback: str; product_review_human_feedback: str; product_review_done: bool;
+    design_doc_current: str; design_doc_feedback: str; design_doc_human_feedback: str; design_doc_done: bool;
+    uml_selected_diagrams: List[str]; uml_current_codes: List[PlantUMLCode]; uml_feedback: Dict[str, str]; uml_human_feedback: Dict[str, str]; uml_done: bool;
+    code_current: GeneratedCode;
+    code_human_input: str; code_web_search_results: str; code_feedback: str; code_human_feedback: str; code_done: bool;
+    code_review_current_feedback: str; security_current_feedback: str; review_security_human_feedback: str; review_security_done: bool;
+    test_cases_current: List[TestCase]; test_cases_feedback: str; test_cases_human_feedback: str; test_cases_passed: bool;
+    quality_current_analysis: str; quality_feedback: str; quality_human_feedback: str; quality_done: bool;
+    deployment_current_process: str; deployment_feedback: str; deployment_human_feedback: str; deployment_done: bool;
+
+
+# --- Constants and Helper Functions ---
+PLANTUML_SYNTAX_RULES = { # Keep the full dictionary
+    # ... (plantuml rules dictionary remains unchanged) ...
+        "Activity Diagram": {"template": "@startuml\nstart\nif (condition) then (yes)\n  :action1;\nelse (no)\n  :action2;\nendif\nwhile (condition)\n  :action3;\nendwhile\nstop\n@enduml", "required_keywords": ["start", ":", "stop"], "notes": "Conditionals: if/else/endif. Loops: while/endwhile. Actions: :action;."},
+    "Sequence Diagram": {"template": "@startuml\nparticipant A\nparticipant B\nA -> B : message\nalt condition\n  B --> A : success\nelse\n  B --> A : failure\nend\n@enduml", "required_keywords": ["participant", "->", "-->"], "notes": "-> solid line, --> dashed line. alt/else/end for alternatives."},
+    "Use Case Diagram": {"template": "@startuml\nactor User\nusecase (UC1)\nUser --> (UC1)\n@enduml", "required_keywords": ["actor", "-->", "("], "notes": "Define actors and use cases, connect with -->."},
+    "Class Diagram": {"template": "@startuml\nclass MyClass {\n  +field: Type\n  +method()\n}\nMyClass --> OtherClass\n@enduml", "required_keywords": ["class", "{", "}", "-->"], "notes": "Define classes, attributes, methods. --> association, <|-- inheritance."},
+    "State Machine Diagram": {"template": "@startuml\n[*] --> State1\nState1 --> State2 : event [condition] / action\nState2 --> [*]\n@enduml", "required_keywords": ["[*]", "-->", ":"], "notes": "[*] start/end. --> transitions with event/condition/action."},
+    "Object Diagram": {"template": "@startuml\nobject obj1: Class1\nobj1 : attr = val\nobj1 --> obj2\n@enduml", "required_keywords": ["object", ":", "-->"], "notes": "Define objects (instances), set attributes, link."},
+    "Component Diagram": {"template": "@startuml\ncomponent Comp1\ninterface Iface\nComp1 ..> Iface\nComp1 --> Comp2\n@enduml", "required_keywords": ["component", "-->"], "notes": "Define components, interfaces. --> dependency, ..> usage."},
+    "Deployment Diagram": {"template": "@startuml\nnode Server {\n  artifact app.jar\n}\n@enduml", "required_keywords": ["node", "artifact"], "notes": "Nodes for hardware/software envs, artifacts for deployed items."},
+    "Package Diagram": {"template": "@startuml\npackage \"My Package\" {\n  class ClassA\n}\n@enduml", "required_keywords": ["package", "{"], "notes": "Group elements."},
+    "Composite Structure Diagram": {"template": "@startuml\nclass Composite {\n  +part1 : Part1\n}\nComposite *-- Part1\n@enduml", "required_keywords": ["class", "{", "}", "*--"], "notes": "Show internal structure, *-- composition."},
+    "Timing Diagram": {"template": "@startuml\nrobust \"User\" as U\nconcise \"System\" as S\n@0\nU is Idle\nS is Ready\n@100\nU -> S : Request()\nS is Processing\n@300\nS --> U : Response()\nU is Active\nS is Ready\n@enduml", "required_keywords": ["@", "is"], "notes": "Show state changes over time."},
+    "Interaction Overview Diagram": {"template": "@startuml\nstart\nif (condition?) then (yes)\n  ref over Actor : Interaction1\nelse (no)\n  :Action A;\nendif\nstop\n@enduml", "required_keywords": ["start", ":", "ref", "stop"], "notes": "Combine activity diagrams with interaction refs."},
+    "Communication Diagram": {"template": "@startuml\nobject O1\nobject O2\nO1 -> O2 : message()\n@enduml", "required_keywords": ["object", "->", ":"], "notes": "Focus on object interactions."},
+    "Profile Diagram": {"template": "@startuml\nprofile MyProfile {\n  stereotype MyStereotype\n}\n@enduml", "required_keywords": ["profile", "stereotype"], "notes": "Define custom stereotypes and tagged values."},
+    "Context Diagram (Level 0 DFD)": {"template": "@startuml\nrectangle System as S\nentity External as E\nE --> S : Data Input\nS --> E : Data Output\n@enduml", "required_keywords": ["rectangle", "entity", "-->", ":"], "notes": "System boundary, external entities, major data flows."},
+    "Level 1 DFD": {"template": "@startuml\nentity E\nrectangle P1\nrectangle P2\ndatabase DS\nE --> P1 : Input\nP1 --> P2 : Data\nP1 --> DS : Store\nP2 --> E : Output\n@enduml", "required_keywords": ["rectangle", "entity", "database", "-->", ":"], "notes": "Major processes, data stores, flows between them."},
+    "Level 2 DFD": {"template": "@startuml\nrectangle P1.1\nrectangle P1.2\ndatabase DS\nP1.1 --> P1.2 : Internal Data\nP1.2 --> DS : Store Detail\n@enduml", "required_keywords": ["rectangle", "-->", ":"], "notes": "Decomposition of Level 1 processes."},
+    "Level 3 DFD": {"template": "@startuml\nrectangle P1.1.1\nrectangle P1.1.2\nP1.1.1 --> P1.1.2 : Sub-detail\n@enduml", "required_keywords": ["rectangle", "-->", ":"], "notes": "Further decomposition."},
+    "General DFD": {"template": "@startuml\nentity E\nrectangle P\ndatabase DS\nE --> P : Input\nP --> DS : Store\nDS --> P : Retrieve\nP --> E : Output\n@enduml", "required_keywords": ["entity", "rectangle", "database", "-->", ":"], "notes": "Generic structure for DFDs."},
+}
+
+def validate_plantuml_code(diagram_type: str, code: str) -> bool:
+    # (validate_plantuml_code function remains unchanged)
+    if diagram_type not in PLANTUML_SYNTAX_RULES:
+        logger.warning(f"Unknown diagram type for validation: {diagram_type}")
+        return False
+    rules = PLANTUML_SYNTAX_RULES[diagram_type]
+    required_keywords = rules.get("required_keywords", [])
+    if not code:
+        logger.warning(f"Empty code provided for {diagram_type}.")
+        return False
+    code_cleaned = code.strip()
+    if not code_cleaned.startswith("@startuml"):
+        logger.warning(f"PlantUML code for {diagram_type} does not start with @startuml.")
+    if not code_cleaned.endswith("@enduml"):
+         logger.warning(f"PlantUML code for {diagram_type} does not end with @enduml.")
+    if required_keywords:
+        missing_keywords = [kw for kw in required_keywords if kw not in code]
+        if missing_keywords:
+            logger.warning(f"PlantUML code for {diagram_type} missing required keywords: {missing_keywords}.")
+    return True
+
+# --- NEW: Initialization Function ---
+def initialize_llm_clients(provider: str, model_name: str, llm_api_key: str, tavily_api_key: str) -> tuple[BaseLanguageModel | None, TavilyClient | None, str | None]:
+    """
+    Initializes LLM and Tavily clients based on user-provided configuration.
+
+    Args:
+        provider: Name of the LLM provider (e.g., "OpenAI", "Groq").
+        model_name: Name of the specific model to use.
+        llm_api_key: API key for the selected LLM provider.
+        tavily_api_key: API key for Tavily search.
+
+    Returns:
+        A tuple containing:
+        - llm_instance: Initialized LangChain LLM instance or None if failed.
+        - tavily_instance: Initialized Tavily client or None if key is missing/invalid.
+        - error_message: A string describing the error if initialization failed, otherwise None.
+    """
+    llm_instance = None
+    tavily_instance = None
+    error_message = None
+    provider_lower = provider.lower()
+
+    # --- Initialize LLM ---
+    try:
+        logger.info(f"Attempting to initialize LLM: Provider='{provider}', Model='{model_name}'")
+        if not llm_api_key:
+            raise ValueError("LLM API Key is required.")
+
+        if provider_lower == "openai":
+            llm_instance = ChatOpenAI(model=model_name, temperature=0.5, api_key=llm_api_key)
+        elif provider_lower == "groq":
+            llm_instance = ChatGroq(model=model_name, temperature=0.5, api_key=llm_api_key)
+        # Add elif blocks for other providers here
+        # elif provider_lower == "google":
+        #     llm_instance = ChatGoogleGenerativeAI(model=model_name, google_api_key=llm_api_key, temperature=0.5)
+        # elif provider_lower == "anthropic":
+        #     llm_instance = ChatAnthropic(model=model_name, anthropic_api_key=llm_api_key, temperature=0.5)
+        else:
+            raise ValueError(f"Unsupported LLM provider: {provider}")
+
+        # Optional: Simple test call to verify the key/model (can increase startup time)
+        # try:
+        #     llm_instance.invoke("Test prompt")
+        #     logger.info(f"LLM {provider} - {model_name} initialized and tested successfully.")
+        # except Exception as test_e:
+        #     logger.error(f"LLM Verification failed for {provider} - {model_name}: {test_e}")
+        #     raise ValueError(f"LLM key or model name might be invalid for {provider}. Error: {test_e}") from test_e
+        logger.info(f"LLM {provider} - {model_name} initialized successfully.")
+
+    except ValueError as ve:
+        error_message = str(ve)
+        logger.error(f"LLM Initialization Error: {error_message}")
+        llm_instance = None
+    except Exception as e:
+        error_message = f"An unexpected error occurred during LLM initialization for {provider}: {e}"
+        logger.error(error_message, exc_info=True)
+        llm_instance = None
+
+    # --- Initialize Tavily ---
+    if tavily_api_key:
+        try:
+            logger.info("Attempting to initialize Tavily client...")
+            tavily_instance = TavilyClient(api_key=tavily_api_key)
+            # Optional: Test Tavily connectivity (e.g., search for 'test')
+            # try:
+            #     tavily_instance.search("test", max_results=1)
+            #     logger.info("Tavily client initialized and tested successfully.")
+            # except Exception as tav_e:
+            #     logger.error(f"Tavily API key might be invalid. Error: {tav_e}")
+            #     if error_message is None: # Prioritize LLM error message
+            #          error_message = f"Tavily API key might be invalid: {tav_e}"
+            #     tavily_instance = None # Failed test
+            logger.info("Tavily client initialized successfully.")
+        except Exception as e:
+            tavily_err = f"Failed to initialize Tavily client: {e}"
+            logger.error(tavily_err, exc_info=True)
+            if error_message is None: # Prioritize LLM error message
+                error_message = tavily_err
+            tavily_instance = None
+    else:
+        logger.warning("Tavily API Key not provided. Web search will be disabled.")
+        tavily_instance = None
+
+    return llm_instance, tavily_instance, error_message
+
+# --- Modified Retry Decorator ---
+# Removed the initial GLOBAL_LLM check
+def with_retry(func):
+    """Decorator to add retry logic to functions, especially LLM calls."""
+    @wraps(func)
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=2, max=10),
+        retry=retry_if_exception_type(Exception),
+        before_sleep=lambda rs: logger.warning(
+            f"Retrying {func.__name__} (attempt {rs.attempt_number}) after {rs.next_action.sleep:.2f}s delay..."
+        )
+    )
+    def wrapper(*args, **kwargs):
+        try:
+            # Execute the decorated function
+            return func(*args, **kwargs)
+        except Exception as e:
+            # Log the error after all retries have failed
+            logger.error(f"Error in {func.__name__} after retries: {e}", exc_info=True)
+            raise # Re-raise the exception
+    return wrapper
+
+# --- Workflow Functions ---
+# --- MODIFIED TO USE state['llm_instance'] and state['tavily_instance'] ---
+
+# --- User Input Cycle ---
+@with_retry
+def generate_questions(state: MainState) -> MainState:
+    """Generates clarification questions."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    context = f"Project: {state['project']} ({state['category']}/{state['subcategory']}) in {state['coding_language']}."
+    iteration = state.get("user_input_iteration", 0)
+    if iteration == 0:
+        prompt = f"You are a requirements analyst. Ask exactly 5 concise questions to clarify the initial needs for this project: {context}"
+    else:
+        qa_history = "\n".join([f"Q: {q}\nA: {a}" for q, a in zip(state.get("user_input_questions",[]), state.get("user_input_answers",[]))])
+        prompt = f"Based on the previous Q&A for the project ({context}), ask up to 5 more concise clarification questions...\nPrevious Q&A:\n{qa_history}"
+    response = llm.invoke(prompt) # Use LLM from state
+    questions = [q.strip() for q in response.content.strip().split("\n") if q.strip()]
+    state["user_input_questions"] = state.get("user_input_questions", []) + questions
+    state["messages"].append(AIMessage(content="\n".join(questions)))
+    logger.info(f"Generated {len(questions)} questions for iteration {iteration}.")
+    return state
+
+@with_retry
+def refine_prompt(state: MainState) -> MainState:
+    """Synthesizes Q&A into a refined prompt."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    qa_history = "\n".join([f"Q: {q}\nA: {a}" for q, a in zip(state.get("user_input_questions",[]), state.get("user_input_answers",[]))])
+    prompt = f"Based on the following Q&A history for project '{state['project']}', synthesize a concise 'Refined Prompt'...\nQ&A History:\n{qa_history}\n---\nOutput ONLY the refined prompt text."
+    response = llm.invoke(prompt) # Use LLM from state
+    refined_prompt_text = response.content.strip()
+    state["refined_prompt"] = refined_prompt_text
+    state["user_query_with_qa"] = qa_history
+    state["messages"].append(AIMessage(content=f"Refined Prompt:\n{refined_prompt_text}"))
+    logger.info("Refined project prompt based on Q&A.")
+    # Save logic remains the same
+    try:
+        project_folder_name = state.get("project_folder", "default_project")
+        abs_project_folder = os.path.abspath(project_folder_name)
+        intro_dir = os.path.join(abs_project_folder, "1_intro")
+        os.makedirs(intro_dir, exist_ok=True)
+        qa_path = os.path.join(intro_dir, "user_query_with_qa.txt")
+        prompt_path = os.path.join(intro_dir, "refined_prompt.md")
+        with open(qa_path, "w", encoding="utf-8") as f: f.write(qa_history)
+        with open(prompt_path, "w", encoding="utf-8") as f: f.write(refined_prompt_text)
+        logger.info(f"Saved Q&A history and refined prompt to {intro_dir}")
+    except Exception as e: logger.error(f"Failed to save intro files: {e}", exc_info=True)
+    return state
+
+# --- User Story Cycle ---
+@with_retry
+def generate_initial_user_stories(state: MainState) -> MainState:
+    """Generates initial user stories."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    prompt = f"Generate a list of user stories for project '{state['project']}' using standard format 'As a..., I want..., so that...'. Base on:\nRefined Prompt:\n{state['refined_prompt']}"
+    response = llm.invoke(prompt) # Use LLM from state
+    initial_user_stories = response.content.strip()
+    state["user_story_current"] = initial_user_stories
+    state["messages"].append(AIMessage(content=f"Initial User Stories:\n{initial_user_stories}"))
+    logger.info("Generated Initial User Stories.")
+    return state
+
+@with_retry
+def generate_user_story_feedback(state: MainState) -> MainState:
+    """Generates AI feedback on user stories."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    prompt = f"Act as QA. Review user stories for clarity, atomicity, testability, alignment...\nUser Stories:\n{state.get('user_story_current', 'N/A')}\n---\nRefined Prompt (Context):\n{state.get('refined_prompt', 'N/A')[:500]}..."
+    response = llm.invoke(prompt) # Use LLM from state
+    feedback = response.content.strip()
+    state["user_story_feedback"] = feedback
+    state["messages"].append(AIMessage(content=f"User Story Feedback:\n{feedback}"))
+    logger.info("Generated feedback on user stories.")
+    return state
+
+@with_retry
+def refine_user_stories(state: MainState) -> MainState:
+    """Refines user stories based on feedback."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    prompt = f"Refine user stories for '{state['project']}' based on feedback.\nCurrent Stories:\n{state.get('user_story_current', 'N/A')}\nAI FB:\n{state.get('user_story_feedback', 'N/A')}\nHuman FB:\n{state.get('user_story_human_feedback', 'N/A')}\n---\nOutput refined list."
+    response = llm.invoke(prompt) # Use LLM from state
+    refined_user_stories = response.content.strip()
+    state["user_story_current"] = refined_user_stories
+    state["messages"].append(AIMessage(content=f"Refined User Stories:\n{refined_user_stories}"))
+    logger.info("Refined User Stories based on feedback.")
+    return state
+
+# save_final_user_story remains unchanged (no LLM calls)
+def save_final_user_story(state: MainState) -> MainState:
+    """Saves the final version of user stories to a file and updates the state."""
+    state["final_user_story"] = state.get("user_story_current", "No user stories generated.")
+    filepath = None # Initialize path as None
+    try:
+        abs_project_folder = os.path.abspath(state["project_folder"])
+        us_dir = os.path.join(abs_project_folder, "2_user_story")
+        os.makedirs(us_dir, exist_ok=True)
+        filepath = os.path.join(us_dir, "final_user_story.md")
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write(state["final_user_story"])
+        logger.info(f"Saved final user story to: {filepath}")
+    except Exception as e:
+        logger.error(f"Failed to save final user story: {e}", exc_info=True)
+        filepath = None # Ensure path is None if saving failed
+    state["final_user_story_path"] = filepath
+    return state
+
+# --- Product Owner Review Cycle ---
+@with_retry
+def generate_initial_product_review(state: MainState) -> MainState:
+    """Generates an initial product review."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    prompt = f"Act as Product Owner for '{state['project']}'. Review prompt and stories, assess alignment, completeness, concerns...\nPrompt:\n{state.get('refined_prompt', 'N/A')}\nStories:\n{state.get('final_user_story', 'N/A')}"
+    response = llm.invoke(prompt) # Use LLM from state
+    initial_review = response.content.strip()
+    state["product_review_current"] = initial_review
+    state["messages"].append(AIMessage(content=f"Initial Product Review:\n{initial_review}"))
+    logger.info("Generated initial product owner review.")
+    return state
+
+@with_retry
+def generate_product_review_feedback(state: MainState) -> MainState:
+    """Generates AI feedback on the product review."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    prompt = f"Review the PO assessment for clarity, logic, priorities...\nPO Review:\n{state.get('product_review_current', 'N/A')}\nStories (Context):\n{state.get('final_user_story', 'N/A')[:1000]}..."
+    response = llm.invoke(prompt) # Use LLM from state
+    feedback = response.content.strip()
+    state["product_review_feedback"] = feedback
+    state["messages"].append(AIMessage(content=f"Product Review Feedback:\n{feedback}"))
+    logger.info("Generated feedback on product review.")
+    return state
+
+@with_retry
+def refine_product_review(state: MainState) -> MainState:
+    """Refines the product review based on feedback."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    prompt = f"Refine the PO review for '{state['project']}' based on feedback.\nCurrent:\n{state.get('product_review_current', 'N/A')}\nAI FB:\n{state.get('product_review_feedback', 'N/A')}\nHuman FB:\n{state.get('product_review_human_feedback', 'N/A')}\n---\nOutput refined review."
+    response = llm.invoke(prompt) # Use LLM from state
+    refined_review = response.content.strip()
+    state["product_review_current"] = refined_review
+    state["messages"].append(AIMessage(content=f"Refined Product Review:\n{refined_review}"))
+    logger.info("Refined product owner review.")
+    return state
+
+# save_final_product_review remains unchanged
+def save_final_product_review(state: MainState) -> MainState:
+    """Saves the final product review to a file."""
+    state["final_product_review"] = state.get("product_review_current", "No review generated.")
+    filepath = None
+    try:
+        abs_project_folder = os.path.abspath(state["project_folder"])
+        pr_dir = os.path.join(abs_project_folder, "3_product_review")
+        os.makedirs(pr_dir, exist_ok=True)
+        filepath = os.path.join(pr_dir, "final_product_review.md")
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write(state["final_product_review"])
+        logger.info(f"Saved final product review to: {filepath}")
+    except Exception as e:
+        logger.error(f"Failed to save final product review: {e}", exc_info=True)
+        filepath = None
+    state["final_product_review_path"] = filepath
+    return state
+
+# --- Design Document Cycle ---
+@with_retry
+def generate_initial_design_doc(state: MainState) -> MainState:
+    """Generates the initial design document."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    prompt = f"Act as System Architect for '{state['project']}'. Create high-level design (Arch, Components, Data, API, Tech, Deploy) based on...\nPrompt:\n{state.get('refined_prompt', 'N/A')}\nStories:\n{state.get('final_user_story', 'N/A')}\nReview:\n{state.get('final_product_review', 'N/A')}"
+    response = llm.invoke(prompt) # Use LLM from state
+    initial_doc = response.content.strip()
+    state["design_doc_current"] = initial_doc
+    state["messages"].append(AIMessage(content=f"Initial Design Document:\n{initial_doc}"))
+    logger.info("Generated Initial Design Document")
+    return state
+
+@with_retry
+def generate_design_doc_feedback(state: MainState) -> MainState:
+    """Generates AI feedback on the design document."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    prompt = f"Review Design Doc for completeness, clarity, consistency, feasibility...\nDoc:\n{state.get('design_doc_current', 'N/A')}\nStories (Context):\n{state.get('final_user_story', 'N/A')[:1000]}..."
+    response = llm.invoke(prompt) # Use LLM from state
+    feedback = response.content.strip()
+    state["design_doc_feedback"] = feedback
+    state["messages"].append(AIMessage(content=f"Design Document Feedback:\n{feedback}"))
+    logger.info("Generated Design Document Feedback")
+    return state
+
+@with_retry
+def refine_design_doc(state: MainState) -> MainState:
+    """Refines the design document based on feedback."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    prompt = f"Refine Design Doc for '{state['project']}' based on feedback.\nCurrent:\n{state.get('design_doc_current', 'N/A')}\nAI FB:\n{state.get('design_doc_feedback', 'N/A')}\nHuman FB:\n{state.get('design_doc_human_feedback', 'N/A')}\n---\nOutput refined doc."
+    response = llm.invoke(prompt) # Use LLM from state
+    refined_doc = response.content.strip()
+    state["design_doc_current"] = refined_doc
+    state["messages"].append(AIMessage(content=f"Refined Design Document:\n{refined_doc}"))
+    logger.info("Refined Design Document")
+    return state
+
+# save_final_design_doc remains unchanged
+def save_final_design_doc(state: MainState) -> MainState:
+    """Saves the final design document."""
+    state["final_design_document"] = state.get("design_doc_current", "No design generated.")
+    filepath = None
+    try:
+        abs_project_folder = os.path.abspath(state["project_folder"])
+        dd_dir = os.path.join(abs_project_folder, "4_design_doc")
+        os.makedirs(dd_dir, exist_ok=True)
+        filepath = os.path.join(dd_dir, "final_design_document.md")
+        with open(filepath, "w", encoding="utf-8") as f: f.write(state["final_design_document"])
+        logger.info(f"Saved final design doc: {filepath}")
+    except Exception as e: logger.error(f"Failed save design doc: {e}", exc_info=True); filepath = None
+    state["final_design_document_path"] = filepath
+    return state
+
+
+# --- UML Diagram Cycle ---
+@with_retry
+def select_uml_diagrams(state: MainState) -> MainState:
+    """Selects relevant UML/DFD diagram types."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    all_diagram_types = ', '.join(PLANTUML_SYNTAX_RULES.keys())
+    prompt = f"Select 5 most relevant UML/DFD types for '{state['project']}' from list [{all_diagram_types}] based on Design Doc:\n{state.get('final_design_document', 'N/A')}\nJustify choices. Output ONLY JSON (DiagramSelection model)."
+    structured_llm = llm.with_structured_output(DiagramSelection) # Use LLM from state
+    response = structured_llm.invoke(prompt)
+    unique_types = list(dict.fromkeys(response.diagram_types))[:5]
+    final_justifications = response.justifications[:len(unique_types)]
+    state["uml_selected_diagrams"] = unique_types
+    display_msg = "Selected Diagrams:\n" + "\n".join(f"- {dt} - {j}" for dt, j in zip(unique_types, final_justifications))
+    state["messages"].append(AIMessage(content=display_msg))
+    logger.info(f"Selected UML Diagrams: {', '.join(unique_types)}")
+    return state
+
+@with_retry
+def generate_initial_uml_codes(state: MainState) -> MainState:
+    """Generates initial PlantUML code for selected diagram types."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    generated_codes = []
+    selected_diagrams = state.get("uml_selected_diagrams", [])
+    if not selected_diagrams: logger.warning("No diagrams selected."); state["uml_current_codes"] = []; return state
+
+    logger.info(f"Generating initial PlantUML code for: {', '.join(selected_diagrams)}")
+    for diagram_type in selected_diagrams:
+        syntax_info = PLANTUML_SYNTAX_RULES.get(diagram_type, {})
+        default_code = "@startuml\n' Default template\n@enduml"
+        code_to_use = syntax_info.get("template", default_code)
+        prompt = f"Generate PlantUML code for a '{diagram_type}' for '{state['project']}'. Base on Design Doc:\n{state.get('final_design_document', 'N/A')[:2000]}...\nAdhere to syntax:\nTemplate:\n{syntax_info.get('template', 'N/A')}\nNotes: {syntax_info.get('notes', 'N/A')}\n---\nGenerate ONLY the PlantUML code block."
+        try:
+            structured_llm = llm.with_structured_output(PlantUMLCode) # Use LLM from state
+            response = structured_llm.invoke(prompt)
+            generated_code = response.code.strip() if response and response.code else ""
+            if validate_plantuml_code(diagram_type, generated_code): code_to_use = generated_code
+            else: logger.warning(f"Generated code for {diagram_type} failed validation. Using template.")
+        except Exception as e: logger.error(f"Failed to generate/validate PlantUML for {diagram_type}: {e}. Using template.", exc_info=True)
+        generated_codes.append(PlantUMLCode(diagram_type=diagram_type, code=code_to_use))
+
+    state["uml_current_codes"] = generated_codes
+    summary = "\n".join([f"**{c.diagram_type}**:\n```plantuml\n{c.code}\n```" for c in generated_codes])
+    state["messages"].append(AIMessage(content=f"Generated Initial UML Codes:\n{summary}"))
+    logger.info(f"Generated initial code for {len(generated_codes)} UML diagrams.")
+    return state
+
+@with_retry
+def generate_uml_feedback(state: MainState) -> MainState:
+    """Generates AI feedback for each current UML diagram."""
+    # Use primary LLM from state, fallback needed? Or rely on app config? Assuming primary.
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    feedback_dict = {}
+    current_codes = state.get('uml_current_codes', [])
+    if not current_codes: logger.warning("No UML codes for feedback."); state["uml_feedback"] = {}; return state
+
+    logger.info(f"Generating feedback for {len(current_codes)} UML diagrams.")
+    for plantuml_code in current_codes:
+        diagram_type = plantuml_code.diagram_type; code_to_review = plantuml_code.code
+        syntax_info = PLANTUML_SYNTAX_RULES.get(diagram_type, {})
+        prompt = f"Review PlantUML code for '{diagram_type}' of '{state['project']}'. Check Syntax, Alignment with Design, Clarity.\nSyntax (Ref):\n{syntax_info.get('template', 'N/A')}\nNotes: {syntax_info.get('notes', 'N/A')}\nCode:\n```plantuml\n{code_to_review}\n```\nDesign (Context):\n{state.get('final_design_document', 'N/A')[:1000]}...\n---\nProvide feedback."
+        try:
+            # Maybe use OPENAI_LLM if available and different? For now, use primary.
+            response = llm.invoke(prompt) # Use LLM from state
+            feedback_dict[diagram_type] = response.content.strip()
+        except Exception as e: logger.error(f"Failed feedback for {diagram_type}: {e}"); feedback_dict[diagram_type] = f"Error: {e}"
+
+    state["uml_feedback"] = feedback_dict
+    summary = "\n\n".join([f"**Feedback for {dt}:**\n{fb}" for dt, fb in feedback_dict.items()])
+    state["messages"].append(AIMessage(content=f"UML Feedback Provided:\n{summary}"))
+    logger.info("Generated feedback for all current UML diagrams.")
+    return state
+
+@with_retry
+def refine_uml_codes(state: MainState) -> MainState:
+    """Refines UML codes based on feedback."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    refined_codes_list = []
+    current_codes = state.get('uml_current_codes', [])
+    ai_feedback = state.get('uml_feedback', {})
+    human_feedback = state.get('uml_human_feedback', {})
+    if not current_codes: logger.warning("No UML codes to refine."); return state
+
+    logger.info(f"Refining {len(current_codes)} UML diagrams.")
+    for plantuml_code_obj in current_codes:
+        diagram_type = plantuml_code_obj.diagram_type; current_code = plantuml_code_obj.code
+        syntax_info = PLANTUML_SYNTAX_RULES.get(diagram_type, {})
+        specific_human_feedback = human_feedback.get(diagram_type, human_feedback.get('all', 'N/A'))
+        prompt = f"Refine PlantUML for '{diagram_type}' of '{state['project']}' based on feedback.\nSyntax (Ref):\n{syntax_info.get('template', 'N/A')}\nNotes: {syntax_info.get('notes', 'N/A')}\nCurrent:\n```plantuml\n{current_code}\n```\nAI FB:\n{ai_feedback.get(diagram_type, 'N/A')}\nHuman FB:\n{specific_human_feedback}\n---\nGenerate ONLY refined PlantUML block."
+        try:
+            structured_llm = llm.with_structured_output(PlantUMLCode) # Use LLM from state
+            response = structured_llm.invoke(prompt)
+            refined_code = response.code.strip() if response and response.code else ""
+            if validate_plantuml_code(diagram_type, refined_code):
+                refined_codes_list.append(PlantUMLCode(diagram_type=diagram_type, code=refined_code))
+            else: logger.warning(f"Refined {diagram_type} invalid. Reverting."); refined_codes_list.append(plantuml_code_obj)
+        except Exception as e: logger.error(f"Failed refine {diagram_type}: {e}. Reverting.", exc_info=True); refined_codes_list.append(plantuml_code_obj)
+
+    state["uml_current_codes"] = refined_codes_list
+    summary = "\n".join([f"**{c.diagram_type} (Refined):**\n```plantuml\n{c.code}\n```" for c in refined_codes_list])
+    state["messages"].append(AIMessage(content=f"Refined UML Codes:\n{summary}"))
+    logger.info(f"Refined {len(refined_codes_list)} UML diagrams.")
+    return state
+
+# save_final_uml_diagrams remains unchanged (no LLM calls)
+def save_final_uml_diagrams(state: MainState) -> MainState:
+    """Saves the final Puml files and attempts to generate PNGs."""
+    state["final_uml_codes"] = state.get("uml_current_codes", [])
+    png_paths = [] # List to store paths of successfully generated PNGs
+    uml_dir = None
+    try:
+        abs_project_folder = os.path.abspath(state["project_folder"])
+        uml_dir = os.path.join(abs_project_folder, "5_uml_diagrams")
+        os.makedirs(uml_dir, exist_ok=True)
+        state["final_uml_diagram_folder"] = uml_dir # Store path to folder
+        can_generate_png = False
+        server = None
+        try:
+            server = PlantUML(url="http://www.plantuml.com/plantuml/png/")
+            can_generate_png = True
+            logger.info("PlantUML server connection appears OK.")
+        except Exception as p_e:
+            logger.warning(f"PlantUML server connection failed: {p_e}. PNG generation will be skipped. Check Java/PlantUML setup and network connectivity.", exc_info=True)
+        if not state["final_uml_codes"]:
+            logger.warning("No UML codes found to save."); state["final_uml_png_paths"] = []; return state
+        logger.info(f"Saving {len(state['final_uml_codes'])} UML diagrams to {uml_dir}...")
+        for i, pc in enumerate(state["final_uml_codes"], 1):
+            safe_type_name = "".join(c if c.isalnum() or c in ['_','-'] else '_' for c in pc.diagram_type).lower()
+            name = f"diagram_{i}_{safe_type_name}"
+            puml_path = os.path.join(uml_dir, f"{name}.puml")
+            png_path = os.path.join(uml_dir, f"{name}.png")
+            try:
+                with open(puml_path, "w", encoding="utf-8") as f: f.write(pc.code)
+                logger.debug(f"Saved PUML file: {puml_path}")
+            except Exception as file_e: logger.error(f"Error saving PUML file {puml_path}: {file_e}", exc_info=True); continue
+            if can_generate_png and server:
+                logger.debug(f"Attempting PNG generation for {name}...")
+                try:
+                    server.processes_file(filename=puml_path, outfile=png_path)
+                    if os.path.exists(png_path) and os.path.getsize(png_path) > 0:
+                        logger.info(f"Successfully generated PNG: {png_path}"); png_paths.append(png_path)
+                    else: logger.error(f"PlantUML processed '{name}' but output PNG is missing or empty: {png_path}")
+                except FileNotFoundError as fnf_err: logger.error(f"PNG generation failed for {name}: Executable/Java not found? Error: {fnf_err}", exc_info=False)
+                except Exception as png_e: logger.error(f"PNG generation failed for {name} ({pc.diagram_type}): {png_e}", exc_info=False)
+            elif not can_generate_png: logger.debug(f"Skipping PNG generation for {name} due to server connection issue.")
+        state["final_uml_png_paths"] = png_paths
+        logger.info(f"Finished UML saving. Saved {len(state['final_uml_codes'])} PUML files. Generated {len(png_paths)} PNG files.")
+    except Exception as e:
+        logger.error(f"General error in save_final_uml_diagrams: {e}", exc_info=True)
+        state["final_uml_diagram_folder"] = None; state["final_uml_png_paths"] = []
+    return state
+
+
+# --- Code Generation Cycle ---
+@with_retry
+def generate_initial_code(state: MainState) -> MainState:
+    """Generates the initial codebase."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    uml_types = ', '.join([c.diagram_type for c in state.get('final_uml_codes', [])])
+    prompt = f"Generate complete, runnable '{state['coding_language']}' project for '{state['project']}'. Base on Design Doc, User Stories, and UML ({uml_types}). Include main scripts, modules, requirements, basic README, comments.\nDesign:\n{state.get('final_design_document', 'N/A')}\nStories (Context):\n{state.get('final_user_story', 'N/A')[:1000]}...\n---\nOutput ONLY JSON (GeneratedCode model)."
+    structured_llm = llm.with_structured_output(GeneratedCode) # Use LLM from state
+    response = structured_llm.invoke(prompt)
+    if not response or not isinstance(response, GeneratedCode) or not response.files:
+        logger.error("Initial code gen failed or invalid format."); raise ValueError("Did not produce expected file structure.")
+    state["code_current"] = response
+    summary = f"Generated {len(response.files)} files. Key: {', '.join([f.filename for f in response.files[:3]])}...\nInstructions:\n{response.instructions[:200]}..."
+    state["messages"].append(AIMessage(content=f"Initial Code Generation:\n{summary}"))
+    logger.info(f"Generated initial code with {len(response.files)} files.")
+    return state
+
+@with_retry
+def web_search_code(state: MainState) -> MainState:
+    """Performs web search based on user feedback."""
+    tavily = state.get('tavily_instance') # Use Tavily from state
+    if not tavily: logger.warning("Tavily client not in state, skipping web search."); state["code_web_search_results"] = "Skipped (Tavily client not configured)"; state["messages"].append(AIMessage(content="Web Search: Skipped")); return state
+    if 'messages' not in state: state['messages'] = []
+    human_input = state.get('code_human_input', '')
+    if not human_input or not human_input.strip(): logger.info("Skipping web search - no issue provided."); state["code_web_search_results"] = "Skipped (No specific issue)"; state["messages"].append(AIMessage(content="Web Search: Skipped")); return state
+    human_input_summary = human_input[:200]; coding_language = state.get('coding_language', 'programming'); project_context = state.get('project', 'project')[:50]
+    search_query = f"{coding_language} issues related to '{human_input_summary}' in {project_context}"
+    logger.info(f"Performing Tavily search: {search_query}")
+    try:
+        response = tavily.search(query=search_query, search_depth="basic", max_results=3) # Use tavily from state
+        search_results = response.get("results", [])
+        if search_results:
+            results_text = "\n\n".join([f"**{r.get('title', 'N/A')}**\nURL: {r.get('url', 'N/A')}\nSnippet: {r.get('content', 'N/A')[:300]}..." for r in search_results])
+            state["code_web_search_results"] = results_text; logger.info(f"Tavily found {len(search_results)} results.")
+        else: state["code_web_search_results"] = "No relevant results found."; logger.info("Tavily found no results.")
+    except Exception as e:
+        error_detail = str(e); logger.error(f"Tavily search failed: {error_detail}", exc_info=True); state["code_web_search_results"] = f"Error during web search: {e}"
+    summary = state['code_web_search_results'][:500] + ('...' if len(state['code_web_search_results']) > 500 else '')
+    state["messages"].append(AIMessage(content=f"Web Search Summary:\n{summary}"))
+    logger.info("Completed Web Search.")
+    return state
+
+@with_retry
+def generate_code_feedback(state: MainState) -> MainState:
+    """Generates AI feedback on the current code."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    func_name = "generate_code_feedback"
+    code_c = state.get("code_current"); instructions = ""
+    # --- CORRECTED LOOP ---
+    code_str_parts = []; total_len = 0; max_code_len = 4000
+    files_to_process = code_c.files if code_c and isinstance(code_c, GeneratedCode) else []
+    if not files_to_process: logger.warning(f"No files in code_current for {func_name}"); code_content = "No code files provided."; instructions = "N/A"
+    else:
+        instructions = code_c.instructions
+        for file in files_to_process:
+            header = f"--- {file.filename} ---\n"; remaining_len = max_code_len - total_len - len(header)
+            if remaining_len <= 0: code_str_parts.append("\n*... (Code context truncated)*"); logger.debug(f"Code context truncated for {func_name}"); break
+            snippet = file.content[:remaining_len]; is_truncated = len(file.content) > remaining_len
+            code_str_parts.append(header + snippet + ('...' if is_truncated else '')); total_len += len(header) + len(snippet)
+            if total_len >= max_code_len:
+                if not code_str_parts[-1].endswith("truncated)*"): code_str_parts.append("\n*... (Code context truncated)*")
+                logger.debug(f"Code context max length for {func_name}"); break
+        code_content = "\n".join(code_str_parts)
+    # --- END CORRECTED LOOP ---
+    prompt = f"Act as reviewer for '{state['project']}' ({state['coding_language']}). Review code, instructions, user feedback, search results. Suggest improvements.\nCode:\n{code_content}\nInstr:\n{instructions}\nUser FB:\n{state.get('code_human_input', 'N/A')}\nSearch:\n{state.get('code_web_search_results', 'N/A')}\n---\nProvide feedback."
+    response = llm.invoke(prompt) # Use LLM from state
+    feedback_text = response.content.strip()
+    state["code_feedback"] = feedback_text
+    state["messages"].append(AIMessage(content=f"AI Code Feedback:\n{feedback_text}"))
+    logger.info("Generated AI feedback on the code.")
+    return state
+
+@with_retry
+def refine_code(state: MainState) -> MainState:
+    """Refines the code based on feedback."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    func_name = "refine_code"
+    code_c = state.get("code_current"); instructions = ""
+    # --- CORRECTED LOOP ---
+    code_str_parts = []; total_len = 0; max_code_len = 3000
+    files_to_process = code_c.files if code_c and isinstance(code_c, GeneratedCode) else []
+    if not files_to_process: logger.warning(f"No files in code_current for {func_name}"); code_content = "No previous code."; instructions = state.get("code_current", GeneratedCode(files=[], instructions="")).instructions
+    else:
+        instructions = code_c.instructions
+        for file in files_to_process:
+            header = f"--- {file.filename} ---\n"; remaining_len = max_code_len - total_len - len(header)
+            if remaining_len <= 0: code_str_parts.append("\n*... (Code context truncated)*"); logger.debug(f"Code context truncated for {func_name}"); break
+            snippet = file.content[:remaining_len]; is_truncated = len(file.content) > remaining_len
+            code_str_parts.append(header + snippet + ('...' if is_truncated else '')); total_len += len(header) + len(snippet)
+            if total_len >= max_code_len:
+                if not code_str_parts[-1].endswith("truncated)*"): code_str_parts.append("\n*... (Code context truncated)*")
+                logger.debug(f"Code context max length for {func_name}"); break
+        code_content = "\n".join(code_str_parts)
+    # --- END CORRECTED LOOP ---
+    prompt = f"Act as senior {state['coding_language']} dev refining '{state['project']}'. Update code based on all feedback. Address bugs, improve style, update instructions if needed.\nCode:\n{code_content}\nInstr:\n{instructions}\nUser Exec FB:\n{state.get('code_human_input','N/A')}\nSearch:\n{state.get('code_web_search_results','N/A')}\nAI Review:\n{state.get('code_feedback','N/A')}\nHuman Comments:\n{state.get('code_human_feedback','N/A')}\n---\nOutput ONLY JSON (GeneratedCode model)."
+    structured_llm = llm.with_structured_output(GeneratedCode) # Use LLM from state
+    response = structured_llm.invoke(prompt)
+    if not response or not isinstance(response, GeneratedCode) or not response.files:
+        logger.error("Code refinement failed or invalid format."); raise ValueError("Did not produce expected file structure.")
+    state["code_current"] = response
+    summary = f"Refined code - {len(response.files)} files. Instructions:\n{response.instructions[:200]}..."
+    state["messages"].append(AIMessage(content=f"Refined Code:\n{summary}"))
+    logger.info(f"Refined code, resulting in {len(response.files)} files.")
+    return state
+
+# --- Code Review & Security Cycle ---
+@with_retry
+def code_review(state: MainState) -> MainState:
+    """Performs code review on final_code_files."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    func_name = "code_review"
+    code_files_to_review = state.get("final_code_files", [])
+    if not code_files_to_review: logger.warning(f"No files in final_code_files for {func_name}"); state["code_review_current_feedback"] = "No code available."; state["messages"].append(AIMessage(content="Code Review: No code.")); return state
+    # --- CORRECTED LOOP ---
+    code_str_parts = []; total_len = 0; max_code_len = 4000
+    instructions = state.get("code_current", GeneratedCode(files=[], instructions="")).instructions
+    files_to_process = code_files_to_review
+    for file in files_to_process:
+        header = f"--- {file.filename} ---\n"; remaining_len = max_code_len - total_len - len(header)
+        if remaining_len <= 0: code_str_parts.append("\n*... (Code context truncated)*"); logger.debug(f"Code context truncated for {func_name}"); break
+        snippet = file.content[:remaining_len]; is_truncated = len(file.content) > remaining_len
+        code_str_parts.append(header + snippet + ('...' if is_truncated else '')); total_len += len(header) + len(snippet)
+        if total_len >= max_code_len:
+            if not code_str_parts[-1].endswith("truncated)*"): code_str_parts.append("\n*... (Code context truncated)*")
+            logger.debug(f"Code context max length for {func_name}"); break
+    code_content = "\n".join(code_str_parts)
+    # --- END CORRECTED LOOP ---
+    prompt = f"Perform detailed code review for '{state['project']}' ({state['coding_language']}). Focus on best practices, readability, logic, efficiency, robustness.\nCode:\n{code_content}\nInstr:\n{instructions}\n---\nProvide feedback."
+    response = llm.invoke(prompt) # Use LLM from state
+    feedback = response.content.strip()
+    state["code_review_current_feedback"] = feedback
+    state["messages"].append(AIMessage(content=f"Code Review:\n{feedback}"))
+    logger.info("Performed code review.")
+    return state
+
+@with_retry
+def security_check(state: MainState) -> MainState:
+    """Performs security check on final_code_files."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    func_name = "security_check"
+    code_files_to_check = state.get("final_code_files", [])
+    if not code_files_to_check: logger.warning(f"No files in final_code_files for {func_name}"); state["security_current_feedback"] = "No code available."; state["messages"].append(AIMessage(content="Security Check: No code.")); return state
+    # --- CORRECTED LOOP ---
+    code_str_parts = []; total_len = 0; max_code_len = 4000
+    instructions = state.get("code_current", GeneratedCode(files=[], instructions="")).instructions
+    files_to_process = code_files_to_check
+    for file in files_to_process:
+        header = f"--- {file.filename} ---\n"; remaining_len = max_code_len - total_len - len(header)
+        if remaining_len <= 0: code_str_parts.append("\n*... (Code context truncated)*"); logger.debug(f"Code context truncated for {func_name}"); break
+        snippet = file.content[:remaining_len]; is_truncated = len(file.content) > remaining_len
+        code_str_parts.append(header + snippet + ('...' if is_truncated else '')); total_len += len(header) + len(snippet)
+        if total_len >= max_code_len:
+            if not code_str_parts[-1].endswith("truncated)*"): code_str_parts.append("\n*... (Code context truncated)*")
+            logger.debug(f"Code context max length for {func_name}"); break
+    code_content = "\n".join(code_str_parts)
+    # --- END CORRECTED LOOP ---
+    prompt = f"Act as security expert. Analyze {state['coding_language']} code for '{state['project']}'. Check for injection, XSS, auth issues, data exposure, input validation, misconfigs, vulnerable deps.\nCode:\n{code_content}\nInstr:\n{instructions}\n---\nProvide findings, impact, remediation."
+    response = llm.invoke(prompt) # Use LLM from state
+    feedback = response.content.strip()
+    state["security_current_feedback"] = feedback
+    state["messages"].append(AIMessage(content=f"Security Check:\n{feedback}"))
+    logger.info("Performed security check.")
+    return state
+
+@with_retry
+def refine_code_with_reviews(state: MainState) -> MainState:
+    """Refines code based on review, security, and human feedback."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    func_name = "refine_code_with_reviews"
+    code_files_to_refine = state.get("final_code_files", [])
+    if not code_files_to_refine: logger.error(f"No files in final_code_files for {func_name}"); raise ValueError("No code available.")
+    instructions = state.get("code_current", GeneratedCode(files=[], instructions="")).instructions
+    # --- CORRECTED LOOP ---
+    code_str_parts = []; total_len = 0; max_code_len = 3000
+    files_to_process = code_files_to_refine
+    if not files_to_process: logger.warning(f"No files for {func_name}"); code_content = "No previous code."
+    else:
+        for file in files_to_process:
+            header = f"--- {file.filename} ---\n"; remaining_len = max_code_len - total_len - len(header)
+            if remaining_len <= 0: code_str_parts.append("\n*... (Code context truncated)*"); logger.debug(f"Code context truncated for {func_name}"); break
+            snippet = file.content[:remaining_len]; is_truncated = len(file.content) > remaining_len
+            code_str_parts.append(header + snippet + ('...' if is_truncated else '')); total_len += len(header) + len(snippet)
+            if total_len >= max_code_len:
+                if not code_str_parts[-1].endswith("truncated)*"): code_str_parts.append("\n*... (Code context truncated)*")
+                logger.debug(f"Code context max length for {func_name}"); break
+        code_content = "\n".join(code_str_parts)
+    # --- END CORRECTED LOOP ---
+    prompt = f"Refine {state['coding_language']} code for '{state['project']}'. Incorporate Code Review, Security Analysis, User Comments. Prioritize security/critical points. Update instructions if needed.\nCode:\n{code_content}\nInstr:\n{instructions}\nReview FB:\n{state.get('code_review_current_feedback', 'N/A')}\nSecurity FB:\n{state.get('security_current_feedback', 'N/A')}\nUser FB:\n{state.get('review_security_human_feedback', 'N/A')}\n---\nOutput ONLY JSON (GeneratedCode model)."
+    structured_llm = llm.with_structured_output(GeneratedCode) # Use LLM from state
+    response = structured_llm.invoke(prompt)
+    if not response or not isinstance(response, GeneratedCode) or not response.files:
+        logger.error("Code refinement post-review failed/invalid."); raise ValueError("Did not produce expected file structure.")
+    state["final_code_files"] = response.files; state["code_current"] = response
+    summary = f"Refined code ({len(response.files)} files) post-review."
+    state["messages"].append(AIMessage(content=f"Code Refined Post-Review:\n{summary}"))
+    logger.info(f"Refined code post-review, {len(response.files)} files.")
+    return state
+
+# save_review_security_outputs remains unchanged
+def save_review_security_outputs(state: MainState) -> MainState:
+    """Saves review/security feedback and the corresponding code snapshot."""
+    state["final_code_review"] = state.get("code_review_current_feedback", "N/A")
+    state["final_security_issues"] = state.get("security_current_feedback", "N/A")
+    rs_dir, code_snap_dir = None, None # Initialize paths
+    try:
+        abs_project_folder = os.path.abspath(state["project_folder"])
+        rs_dir = os.path.join(abs_project_folder, "6_review_security")
+        os.makedirs(rs_dir, exist_ok=True)
+        code_snap_dir = os.path.join(rs_dir, "code_snapshot")
+        os.makedirs(code_snap_dir, exist_ok=True)
+
+        # Store paths in state
+        state["final_review_security_folder"] = rs_dir
+        state["review_code_snapshot_folder"] = code_snap_dir
+
+        # Save feedback files
+        review_path = os.path.join(rs_dir, "final_code_review.md")
+        security_path = os.path.join(rs_dir, "final_security_issues.md")
+        with open(review_path, "w", encoding="utf-8") as f: f.write(state["final_code_review"])
+        with open(security_path, "w", encoding="utf-8") as f: f.write(state["final_security_issues"])
+        logger.debug(f"Saved review feedback files to {rs_dir}")
+
+        # Save the code snapshot (should be the version just refined)
+        files_to_save = state.get("final_code_files", [])
+        instructions = state.get("code_current", GeneratedCode(files=[], instructions="")).instructions
+
+        if files_to_save:
+            logger.info(f"Saving {len(files_to_save)} code files to snapshot folder: {code_snap_dir}")
+            for file in files_to_save:
+                filename = file.filename; content = file.content
+                relative_path = filename.lstrip('/\\'); filepath = os.path.normpath(os.path.join(code_snap_dir, relative_path))
+                if not os.path.abspath(filepath).startswith(os.path.abspath(code_snap_dir)):
+                    logger.warning(f"Attempted path traversal! Skipping file: {filename} -> {filepath}"); continue
+                try:
+                    os.makedirs(os.path.dirname(filepath), exist_ok=True)
+                    with open(filepath, "w", encoding="utf-8") as f: f.write(content)
+                    logger.debug(f"Saved code file: {filepath}")
+                except OSError as path_err: logger.error(f"Could not create directory or save file '{filepath}': {path_err}")
+                except Exception as write_err: logger.error(f"Error writing file '{filepath}': {write_err}")
+            try: # Save instructions
+                instr_path = os.path.join(code_snap_dir, "instructions.md")
+                with open(instr_path, "w", encoding="utf-8") as f: f.write(instructions)
+                logger.debug(f"Saved instructions file: {instr_path}")
+            except Exception as instr_err: logger.error(f"Error writing instructions file: {instr_err}")
+            logger.info(f"Finished saving review/security outputs and code snapshot to {rs_dir}")
+        else: logger.warning("No code files found in 'final_code_files' to save for review snapshot.")
+    except Exception as e:
+        logger.error(f"General error in save_review_security_outputs: {e}", exc_info=True)
+        state["final_review_security_folder"] = None; state["review_code_snapshot_folder"] = None
+    return state
+
+# --- Test Case Generation Cycle ---
+@with_retry
+def generate_initial_test_cases(state: MainState) -> MainState:
+    """Generates initial test cases."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    func_name = "generate_initial_test_cases"
+    # --- RECOMMENDED: Use corrected loop ---
+    code_str_parts = []; total_len = 0; max_code_len = 2000
+    files_to_process = state.get("final_code_files", [])
+    if not files_to_process: logger.warning(f"No files for {func_name}"); code_str = "No code files provided."
+    else:
+        for file in files_to_process:
+            header = f"--- {file.filename} ---\n"; remaining_len = max_code_len - total_len - len(header)
+            if remaining_len <= 0: code_str_parts.append("\n*... (Code context truncated)*"); break
+            snippet = file.content[:remaining_len]; is_truncated = len(file.content) > remaining_len
+            code_str_parts.append(header + snippet + ('...' if is_truncated else '')); total_len += len(header) + len(snippet)
+            if total_len >= max_code_len:
+                if not code_str_parts[-1].endswith("truncated)*"): code_str_parts.append("\n*... (Code context truncated)*")
+                break
+        code_str = "\n".join(code_str_parts)
+    # --- END RECOMMENDED LOOP ---
+    if not state.get("final_code_files"): raise ValueError("No code found for test case generation.")
+    prompt = f"Generate >=3 diverse test cases (happy, edge, error) for '{state['project']}' ({state['coding_language']}). Base on stories, design, code.\nStories:\n{state.get('final_user_story', 'N/A')[:1000]}...\nDesign:\n{state.get('final_design_document', 'N/A')[:1000]}...\nCode:\n{code_str}\n---\nOutput ONLY JSON (TestCases model)."
+    structured_llm = llm.with_structured_output(TestCases) # Use LLM from state
+    response = structured_llm.invoke(prompt)
+    if not response or not isinstance(response, TestCases) or not response.test_cases:
+        logger.error("Test case gen failed/invalid."); raise ValueError("Did not produce valid test cases.")
+    state["test_cases_current"] = response.test_cases
+    summary = "\n".join([f"- {tc.description}" for tc in response.test_cases])
+    state["messages"].append(AIMessage(content=f"Generated Initial Test Cases:\n{summary}"))
+    logger.info(f"Generated {len(response.test_cases)} initial test cases.")
+    return state
+
+@with_retry
+def generate_test_cases_feedback(state: MainState) -> MainState:
+    """Generates AI feedback on test cases."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    current_tests = state.get("test_cases_current", [])
+    if not current_tests: logger.warning("No test cases for feedback."); state["test_cases_feedback"] = "No tests found."; return state
+    tests_str = "\n".join([f"- {tc.description}: Input={tc.input_data}, Expected={tc.expected_output}" for tc in current_tests])
+    code_files = state.get("final_code_files", []); code_sample = code_files[0].content[:500] + '...' if code_files else "N/A"
+    prompt = f"Review test cases for '{state['project']}'. Assess coverage, clarity, effectiveness, realism. Suggest improvements.\nTests:\n{tests_str}\nStories (Context):\n{state.get('final_user_story', 'N/A')[:1000]}...\nCode (Context):\n{code_sample}\n---\nProvide feedback."
+    response = llm.invoke(prompt) # Use LLM from state
+    feedback = response.content.strip()
+    state["test_cases_feedback"] = feedback
+    state["messages"].append(AIMessage(content=f"Test Case Feedback:\n{feedback}"))
+    logger.info("Generated feedback on test cases.")
+    return state
+
+@with_retry
+def refine_test_cases_and_code(state: MainState) -> MainState:
+    """Refines test cases and code based on feedback."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    func_name = "refine_test_cases_and_code"
+    current_tests = state.get("test_cases_current", []); current_code_files = state.get("final_code_files", [])
+    instructions = state.get("code_current", GeneratedCode(files=[], instructions="")).instructions
+    if not current_tests or not current_code_files: logger.error(f"Missing tests or code for {func_name}"); raise ValueError("Missing data.")
+    tests_str = "\n".join([f"- {tc.description}: Input={tc.input_data}, Expected={tc.expected_output}" for tc in current_tests])
+    # --- CORRECTED LOOP ---
+    code_str_parts = []; total_len = 0; max_code_len = 3000
+    files_to_process = current_code_files
+    if not files_to_process: logger.warning(f"No files for {func_name}"); code_str = "No code."
+    else:
+        for file in files_to_process:
+            header = f"--- {file.filename} ---\n"; remaining_len = max_code_len - total_len - len(header)
+            if remaining_len <= 0: code_str_parts.append("\n*... (Code context truncated)*"); logger.debug(f"Code context truncated for {func_name}"); break
+            snippet = file.content[:remaining_len]; is_truncated = len(file.content) > remaining_len
+            code_str_parts.append(header + snippet + ('...' if is_truncated else '')); total_len += len(header) + len(snippet)
+            if total_len >= max_code_len:
+                if not code_str_parts[-1].endswith("truncated)*"): code_str_parts.append("\n*... (Code context truncated)*")
+                logger.debug(f"Code context max length for {func_name}"); break
+        code_str = "\n".join(code_str_parts)
+    # --- END CORRECTED LOOP ---
+    class TestAndCode(BaseModel):
+        test_cases: List[TestCase]; files: List[CodeFile]
+    prompt = f"Tests failed for '{state['project']}'. Refine BOTH tests AND code based on feedback. Goal: refined code passes refined tests.\nTests:\n{tests_str}\nCode:\n{code_str}\nInstr:\n{instructions}\nAI Test FB:\n{state.get('test_cases_feedback','N/A')}\nHuman FB/Results:\n{state.get('test_cases_human_feedback','N/A')}\n---\nOutput ONLY JSON (TestAndCode model)."
+    structured_llm = llm.with_structured_output(TestAndCode) # Use LLM from state
+    response = structured_llm.invoke(prompt)
+    if not response or not isinstance(response, TestAndCode) or not response.test_cases or not response.files:
+        logger.error("Refinement of tests/code failed/invalid."); raise ValueError("Did not produce expected results.")
+    state["test_cases_current"] = response.test_cases; state["final_code_files"] = response.files
+    state["code_current"] = GeneratedCode(files=response.files, instructions=instructions) # Keep old instructions
+    summary = f"Refined {len(response.files)} code files & {len(response.test_cases)} tests."
+    state["messages"].append(AIMessage(content=f"Refined Tests and Code:\n{summary}"))
+    logger.info("Refined test cases and code.")
+    return state
+
+# save_testing_outputs remains unchanged
+def save_testing_outputs(state: MainState) -> MainState:
+    """Saves the final tests and the code version that passed them."""
+    state["final_test_code_files"] = state.get("final_code_files", [])
+    final_tests = state.get("test_cases_current", [])
+    test_dir, code_snap_dir = None, None
+    try:
+        abs_project_folder = os.path.abspath(state["project_folder"])
+        test_dir = os.path.join(abs_project_folder, "7_testing"); os.makedirs(test_dir, exist_ok=True)
+        code_snap_dir = os.path.join(test_dir, "passed_code"); os.makedirs(code_snap_dir, exist_ok=True)
+        state["final_testing_folder"] = test_dir; state["testing_passed_code_folder"] = code_snap_dir
+
+        # Save test cases file
+        tc_path = os.path.join(test_dir, "final_test_cases.md")
+        tc_str = "\n\n".join([f"**{tc.description}**\nInput:`{tc.input_data}`\nExpected:`{tc.expected_output}`" for tc in final_tests])
+        with open(tc_path, "w", encoding="utf-8") as f: f.write(f"# Final Test Cases ({len(final_tests)} Passed)\n\n{tc_str}")
+        logger.debug(f"Saved test cases file: {tc_path}")
+
+        # Save the code snapshot that passed
+        passed_code_files = state.get("final_test_code_files",[]);
+        instructions = state.get("code_current", GeneratedCode(files=[],instructions="")).instructions
+        if passed_code_files:
+            logger.info(f"Saving {len(passed_code_files)} passed code files to snapshot: {code_snap_dir}")
+            for file in passed_code_files: # Save files with path safety
+                fn=file.filename; content=file.content; safe_fn=os.path.basename(fn)
+                if not safe_fn or ('/' in fn and '..' in fn) or ('\\' in fn and '..' in fn): logger.warning(f"Skip unsafe file: {fn}"); continue
+                rel_path=fn.lstrip('/\\'); filepath=os.path.normpath(os.path.join(code_snap_dir, rel_path))
+                if not os.path.abspath(filepath).startswith(os.path.abspath(code_snap_dir)): logger.warning(f"Skip traversal: {fn}"); continue
+                try:
+                    os.makedirs(os.path.dirname(filepath), exist_ok=True);
+                    with open(filepath, "w", encoding="utf-8") as f: f.write(content)
+                    logger.debug(f"Saved code file: {filepath}")
+                except OSError as path_err: logger.error(f"Path error saving '{filepath}': {path_err}")
+                except Exception as write_err: logger.error(f"Error writing '{filepath}': {write_err}")
+            try: # Save instructions
+                instr_path = os.path.join(code_snap_dir, "instructions.md")
+                with open(instr_path,"w",encoding="utf-8") as f: f.write(instructions)
+                logger.debug(f"Saved instructions: {instr_path}")
+            except Exception as instr_err: logger.error(f"Error writing instructions: {instr_err}")
+            logger.info(f"Finished saving testing outputs and passed code to {test_dir}")
+        else: logger.warning("No passed code files found in state to save.")
+    except Exception as e: logger.error(f"Failed save testing outputs: {e}", exc_info=True); state["final_testing_folder"]=None; state["testing_passed_code_folder"]=None
+    return state
+
+
+# --- Quality Analysis Cycle ---
+@with_retry
+def generate_initial_quality_analysis(state: MainState) -> MainState:
+    """Generates an overall quality analysis report."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    func_name = "generate_initial_quality_analysis"
+    code_files_passed = state.get("final_test_code_files", [])
+    instructions = state.get("code_current", GeneratedCode(files=[], instructions="")).instructions
+    if not code_files_passed: logger.warning(f"No tested code for {func_name}."); state["quality_current_analysis"] = "No passed code available."; return state
+    # --- CORRECTED LOOP ---
+    code_str_parts = []; total_len = 0; max_code_len = 4000
+    files_to_process = code_files_passed
+    if not files_to_process: logger.error(f"Logic error: files_to_process empty in {func_name}"); code_str = "Error retrieving code."
+    else:
+        for file in files_to_process:
+            header = f"--- {file.filename} ---\n"; remaining_len = max_code_len - total_len - len(header)
+            if remaining_len <= 0: code_str_parts.append("\n*... (Code context truncated)*"); logger.debug(f"Code context truncated for {func_name}"); break
+            snippet = file.content[:remaining_len]; is_truncated = len(file.content) > remaining_len
+            code_str_parts.append(header + snippet + ('...' if is_truncated else '')); total_len += len(header) + len(snippet)
+            if total_len >= max_code_len:
+                if not code_str_parts[-1].endswith("truncated)*"): code_str_parts.append("\n*... (Code context truncated)*")
+                logger.debug(f"Code context max length for {func_name}"); break
+        code_str = "\n".join(code_str_parts)
+    # --- END CORRECTED LOOP ---
+    tests_str = "\n".join([f"- {tc.description}" for tc in state.get("test_cases_current", [])])[:500] + "..."
+    prompt = f"Generate QA report for '{state['project']}' ({state['coding_language']}). Code passed tests. Assess Maintainability, Perf, Scale, Security, Coverage, Docs, Confidence Score (1-10).\nCode:\n{code_str}\nTests:\n{tests_str}\nInstr:\n{instructions}\nReview Sum:\n{state.get('final_code_review','N/A')[:500]}...\nSecurity Sum:\n{state.get('final_security_issues','N/A')[:500]}...\n---"
+    response = llm.invoke(prompt) # Use LLM from state
+    qa_report = response.content.strip()
+    state["quality_current_analysis"] = qa_report
+    state["messages"].append(AIMessage(content=f"Initial Quality Analysis Report:\n{qa_report}"))
+    logger.info("Generated Initial Quality Analysis Report.")
+    return state
+
+@with_retry
+def generate_quality_feedback(state: MainState) -> MainState:
+    """Generates AI feedback on the QA report."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    current_qa_report = state.get('quality_current_analysis', 'N/A')
+    if current_qa_report == 'N/A': logger.warning("No QA report for feedback."); state["quality_feedback"] = "No QA report."; return state
+    prompt = f"Review QA report for '{state['project']}'. Critique fairness, comprehensiveness, logic, missing aspects.\nReport:\n{current_qa_report}"
+    response = llm.invoke(prompt) # Use LLM from state
+    feedback = response.content.strip()
+    state["quality_feedback"] = feedback
+    state["messages"].append(AIMessage(content=f"Feedback on QA Report:\n{feedback}"))
+    logger.info("Generated feedback on the Quality Analysis report.")
+    return state
+
+@with_retry
+def refine_quality_and_code(state: MainState) -> MainState:
+    """Refines QA report and potentially minor code aspects."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    func_name = "refine_quality_and_code"
+    code_files_base = state.get("final_test_code_files", [])
+    instructions = state.get("code_current", GeneratedCode(files=[], instructions="")).instructions
+    # --- CORRECTED LOOP ---
+    code_str_parts = []; total_len = 0; max_code_len = 2000
+    files_to_process = code_files_base
+    if not files_to_process: logger.warning(f"No tested code for {func_name}"); code_content = "N/A"
+    else:
+        for file in files_to_process:
+            header = f"--- {file.filename} ---\n"; remaining_len = max_code_len - total_len - len(header)
+            if remaining_len <= 0: code_str_parts.append("\n*... (Code context truncated)*"); logger.debug(f"Code context truncated for {func_name}"); break
+            snippet = file.content[:remaining_len]; is_truncated = len(file.content) > remaining_len
+            code_str_parts.append(header + snippet + ('...' if is_truncated else '')); total_len += len(header) + len(snippet)
+            if total_len >= max_code_len:
+                if not code_str_parts[-1].endswith("truncated)*"): code_str_parts.append("\n*... (Code context truncated)*")
+                logger.debug(f"Code context max length for {func_name}"); break
+        code_content = "\n".join(code_str_parts)
+    # --- END CORRECTED LOOP ---
+    class QualityAndCode(BaseModel):
+        analysis: str; files: List[CodeFile]
+    prompt = f"Refine QA report for '{state['project']}' based on feedback. Also apply *minor, non-functional* code improvements (docs, names) suggested by feedback to 'Passed Code' if simple, else return original files.\nQA Report:\n{state.get('quality_current_analysis','N/A')}\nPassed Code:\n{code_content}\nInstr:\n{instructions}\nAI FB:\n{state.get('quality_feedback','N/A')}\nHuman FB:\n{state.get('quality_human_feedback','N/A')}\n---\nOutput ONLY JSON (QualityAndCode model)."
+    structured_llm = llm.with_structured_output(QualityAndCode) # Use LLM from state
+    response = structured_llm.invoke(prompt)
+    if not response or not isinstance(response, QualityAndCode) or not response.analysis:
+        logger.error("Refinement of QA report failed/invalid."); raise ValueError("Did not produce expected result.")
+    state["quality_current_analysis"] = response.analysis; state["final_code_files"] = response.files
+    current_instructions = state.get("code_current", GeneratedCode(files=[],instructions="")).instructions
+    state["code_current"] = GeneratedCode(files=response.files, instructions=current_instructions)
+    state["messages"].append(AIMessage(content=f"Refined Quality Analysis Report:\n{state['quality_current_analysis']}"))
+    logger.info("Refined Quality Analysis report.")
+    return state
+
+# save_final_quality_analysis remains unchanged
+def save_final_quality_analysis(state: MainState) -> MainState:
+    """Saves the final QA report and the associated final code snapshot."""
+    state["final_quality_analysis"] = state.get("quality_current_analysis", "N/A")
+    qa_dir, code_snap_dir, qa_path = None, None, None
+    try:
+        abs_project_folder = os.path.abspath(state["project_folder"])
+        qa_dir = os.path.join(abs_project_folder, "8_quality_analysis"); os.makedirs(qa_dir, exist_ok=True)
+        qa_path = os.path.join(qa_dir, "final_quality_analysis.md")
+        with open(qa_path, "w", encoding="utf-8") as f: f.write(state["final_quality_analysis"])
+        state["final_quality_analysis_path"] = qa_path; logger.info(f"Saved final QA report: {qa_path}")
+        code_snap_dir = os.path.join(qa_dir, "final_code"); os.makedirs(code_snap_dir, exist_ok=True)
+        state["final_code_folder"] = code_snap_dir
+        files_to_save = state.get("final_code_files",[]); instructions = state.get("code_current", GeneratedCode(files=[],instructions="")).instructions
+        if files_to_save:
+            logger.info(f"Saving final code snapshot ({len(files_to_save)} files) to {code_snap_dir}")
+            for file in files_to_save:
+                fn=file.filename; content=file.content; safe_fn=os.path.basename(fn)
+                if not safe_fn or ('/' in fn and '..' in fn) or ('\\' in fn and '..' in fn): logger.warning(f"Skip unsafe file: {fn}"); continue
+                rel_path=fn.lstrip('/\\'); filepath=os.path.normpath(os.path.join(code_snap_dir, rel_path))
+                if not os.path.abspath(filepath).startswith(os.path.abspath(code_snap_dir)): logger.warning(f"Skip traversal: {fn}"); continue
+                try:
+                    os.makedirs(os.path.dirname(filepath), exist_ok=True);
+                    with open(filepath, "w", encoding="utf-8") as f: f.write(content)
+                    logger.debug(f"Saved final code file: {filepath}")
+                except OSError as path_err: logger.error(f"Path error saving final code '{filepath}': {path_err}")
+                except Exception as write_err: logger.error(f"Error writing final code '{filepath}': {write_err}")
+            try: # Save instructions
+                instr_path = os.path.join(code_snap_dir, "instructions.md")
+                with open(instr_path,"w",encoding="utf-8") as f: f.write(instructions)
+                logger.debug(f"Saved final instructions: {instr_path}")
+            except Exception as instr_err: logger.error(f"Error writing final instructions: {instr_err}")
+        else: logger.warning("No final code files found to save with QA report.")
+    except Exception as e:
+        logger.error(f"Failed saving QA outputs: {e}", exc_info=True);
+        state["final_quality_analysis_path"]=None; state["final_code_folder"]=None
+    return state
+
+# --- Deployment Cycle ---
+@with_retry
+def generate_initial_deployment(state: MainState, prefs: str) -> MainState:
+    """Generates initial deployment plan."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    func_name = "generate_initial_deployment"
+    final_code = state.get("final_code_files", [])
+    if not final_code: logger.error(f"No final code for {func_name}"); raise ValueError("Final code missing.")
+    instructions = state.get("code_current", GeneratedCode(files=[], instructions="")).instructions
+    # --- CORRECTED LOOP ---
+    code_str_parts = []; total_len = 0; max_code_len = 2000
+    files_to_process = final_code
+    if not files_to_process: logger.warning(f"No files for {func_name}"); code_context = "No code files."
+    else:
+        for file in files_to_process:
+            is_key_file = ("requirements" in file.filename.lower() or "dockerfile" in file.filename.lower() or "main." in file.filename.lower() or "app." in file.filename.lower() or ".env" in file.filename.lower() or "config" in file.filename.lower())
+            if is_key_file:
+                header = f"--- {file.filename} ---\n"; remaining_len = max_code_len - total_len - len(header)
+                if remaining_len <= 0: code_str_parts.append("\n*... (Key file context truncated)*"); logger.debug(f"Key file context truncated for {func_name}"); break
+                snippet = file.content[:remaining_len]; is_truncated = len(file.content) > remaining_len
+                code_str_parts.append(header + snippet + ('...' if is_truncated else '')); total_len += len(header) + len(snippet)
+                if total_len >= max_code_len:
+                    if not code_str_parts[-1].endswith("truncated)*"): code_str_parts.append("\n*... (Key file context truncated)*")
+                    logger.debug(f"Key file context max length for {func_name}"); break
+        code_context = "\n".join(code_str_parts) if code_str_parts else "No key deployment files found."
+    # --- END CORRECTED LOOP ---
+    prompt = f"Act as DevOps. Generate detailed deployment plan for '{state['project']}' ({state['coding_language']}). Base on user prefs, code structure (reqs, docker). Include commands, examples, verification steps.\nPrefs:\n{prefs}\nCode Context (Key Files):\n{code_context}\nInstr:\n{instructions}\n---"
+    response = llm.invoke(prompt) # Use LLM from state
+    deployment_plan = response.content.strip()
+    state["deployment_current_process"] = deployment_plan
+    state["messages"].append(AIMessage(content=f"Initial Deployment Plan:\n{deployment_plan}"))
+    logger.info("Generated initial deployment plan.")
+    return state
+
+@with_retry
+def generate_deployment_feedback(state: MainState) -> MainState:
+    """Generates AI feedback on deployment plan."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    current_plan = state.get('deployment_current_process', 'N/A')
+    if current_plan == 'N/A': logger.warning("No deploy plan to review."); state["deployment_feedback"] = "No plan."; return state
+    prompt = f"Review Deployment Plan for '{state['project']}'. Assess clarity, correctness, completeness, security, alignment with practices.\nPlan:\n{current_plan}\n---\nSuggest improvements."
+    response = llm.invoke(prompt) # Use LLM from state
+    feedback = response.content.strip()
+    state["deployment_feedback"] = feedback
+    state["messages"].append(AIMessage(content=f"Deployment Plan Feedback:\n{feedback}"))
+    logger.info("Generated feedback on deployment plan.")
+    return state
+
+@with_retry
+def refine_deployment(state: MainState) -> MainState:
+    """Refines deployment plan based on feedback."""
+    llm = state.get('llm_instance')
+    if not llm: raise ConnectionError("LLM instance not found in state.")
+    if 'messages' not in state: state['messages'] = []
+    func_name = "refine_deployment"
+    current_plan = state.get('deployment_current_process', 'N/A'); ai_feedback = state.get('deployment_feedback', 'N/A'); human_feedback = state.get('deployment_human_feedback', 'N/A')
+    # --- ADDED LOOP ---
+    code_str_parts = []; total_len = 0; max_code_len = 2000
+    final_code = state.get("final_code_files", []); instructions = state.get("code_current", GeneratedCode(files=[], instructions="")).instructions
+    files_to_process = final_code
+    if not files_to_process: logger.warning(f"No files for {func_name}"); code_context = "No code files."
+    else:
+        for file in files_to_process:
+            is_key_file = ("requirements" in file.filename.lower() or "dockerfile" in file.filename.lower() or "main." in file.filename.lower() or "app." in file.filename.lower() or ".env" in file.filename.lower() or "config" in file.filename.lower())
+            if is_key_file:
+                header = f"--- {file.filename} ---\n"; remaining_len = max_code_len - total_len - len(header)
+                if remaining_len <= 0: code_str_parts.append("\n*... (Key file context truncated)*"); logger.debug(f"Key file context truncated for {func_name}"); break
+                snippet = file.content[:remaining_len]; is_truncated = len(file.content) > remaining_len
+                code_str_parts.append(header + snippet + ('...' if is_truncated else '')); total_len += len(header) + len(snippet)
+                if total_len >= max_code_len:
+                    if not code_str_parts[-1].endswith("truncated)*"): code_str_parts.append("\n*... (Key file context truncated)*")
+                    logger.debug(f"Key file context max length for {func_name}"); break
+        code_context = "\n".join(code_str_parts) if code_str_parts else "No key files."
+    # --- END ADDED LOOP ---
+    prompt = f"Refine deployment plan for '{state['project']}'. Update based on feedback.\nCurrent Plan:\n{current_plan}\nCode Context:\n{code_context}\nInstr:\n{instructions}\nAI FB:\n{ai_feedback}\nHuman FB:\n{human_feedback}\n---\nGenerate updated plan."
+    response = llm.invoke(prompt) # Use LLM from state
+    refined_plan = response.content.strip()
+    state["deployment_current_process"] = refined_plan
+    state["messages"].append(AIMessage(content=f"Refined Deployment Plan:\n{refined_plan}"))
+    logger.info("Refined deployment plan.")
+    return state
+
+# save_final_deployment_plan remains unchanged
+def save_final_deployment_plan(state: MainState) -> MainState:
+    """Saves the final deployment plan."""
+    state["final_deployment_process"] = state.get("deployment_current_process", "No deployment plan generated.")
+    filepath = None
+    try:
+        abs_project_folder = os.path.abspath(state["project_folder"])
+        deploy_dir = os.path.join(abs_project_folder, "9_deployment"); os.makedirs(deploy_dir, exist_ok=True)
+        filepath = os.path.join(deploy_dir, "final_deployment_plan.md")
+        with open(filepath, "w", encoding="utf-8") as f: f.write(state["final_deployment_process"])
+        logger.info(f"Saved final deployment plan: {filepath}")
+    except Exception as e: logger.error(f"Failed save deployment plan: {e}", exc_info=True); filepath=None
+    state["final_deployment_path"] = filepath
+    return state
+
+# --- END OF newSDLC.py ---

app.py

@@ -0,0 +1,653 @@
+# app.py
+"""
+Streamlit frontend application for orchestrating an AI-driven SDLC workflow.
+
+This application manages the user interface, state transitions, and calls
+backend logic functions defined in SDLC.py to generate project artifacts.
+"""
+
+import streamlit as st
+import os
+import shutil
+import logging
+from datetime import datetime
+import time
+import zipfile # Standard library zipfile
+
+# --- Import core logic from SDLC.py ---
+try:
+    import SDLC
+    from SDLC import (
+        # State and Models
+        MainState, GeneratedCode, PlantUMLCode, TestCase, CodeFile, TestCases,
+        # NEW: Initialization function
+        initialize_llm_clients,
+        # Workflow Functions
+        generate_questions, refine_prompt,
+        generate_initial_user_stories, generate_user_story_feedback, refine_user_stories, save_final_user_story,
+        generate_initial_product_review, generate_product_review_feedback, refine_product_review, save_final_product_review,
+        generate_initial_design_doc, generate_design_doc_feedback, refine_design_doc, save_final_design_doc,
+        select_uml_diagrams, generate_initial_uml_codes, generate_uml_feedback, refine_uml_codes, save_final_uml_diagrams,
+        generate_initial_code, web_search_code, generate_code_feedback, refine_code,
+        code_review, security_check, refine_code_with_reviews, save_review_security_outputs,
+        generate_initial_test_cases, generate_test_cases_feedback, refine_test_cases_and_code, save_testing_outputs,
+        generate_initial_quality_analysis, generate_quality_feedback, refine_quality_and_code, save_final_quality_analysis,
+        generate_initial_deployment, generate_deployment_feedback, refine_deployment, save_final_deployment_plan,
+        # Message Types
+        HumanMessage, AIMessage
+    )
+    logging.info("Successfully imported components from SDLC.py.")
+except ImportError as e:
+    st.error(f"Import Error: {e}. Critical file 'SDLC.py' not found or contains errors.")
+    logging.critical(f"Failed to import SDLC.py: {e}", exc_info=True)
+    st.stop()
+except Exception as e:
+    st.error(f"An unexpected error occurred during import from SDLC: {e}")
+    logging.critical(f"Unexpected error during import from SDLC: {e}", exc_info=True)
+    st.stop()
+
+# --- Application Setup ---
+st.set_page_config(layout="wide", page_title="AI SDLC Workflow")
+logger = logging.getLogger(__name__)
+if not logger.handlers:
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    logger.info("Streamlit app logger configured.")
+
+# --- Constants for Configuration ---
+AVAILABLE_MODELS = {
+    "OpenAI": ["gpt-4o", "gpt-4-turbo", "gpt-3.5-turbo"],
+    "Groq": ["llama3-8b-8192", "llama3-70b-8192", "mixtral-8x7b-32768", "gemma-7b-it"],
+    # Add more providers and models here if supported in initialize_llm_clients
+}
+LLM_PROVIDERS = list(AVAILABLE_MODELS.keys())
+
+# --- Define Cycle Order and Stage-to-Cycle Mapping ---
+CYCLE_ORDER = [ "Requirements", "User Story", "Product Review", "Design", "UML", "Code Generation", "Review & Security", "Testing", "Quality Analysis", "Deployment" ]
+STAGE_TO_CYCLE = { "initial_setup": "Requirements", "run_generate_questions": "Requirements", "collect_answers": "Requirements", "run_refine_prompt": "Requirements", "run_generate_initial_user_stories": "User Story", "run_generate_user_story_feedback": "User Story", "collect_user_story_human_feedback": "User Story", "run_refine_user_stories": "User Story", "collect_user_story_decision": "User Story", "run_generate_initial_product_review": "Product Review", "run_generate_product_review_feedback": "Product Review", "collect_product_review_human_feedback": "Product Review", "run_refine_product_review": "Product Review", "collect_product_review_decision": "Product Review", "run_generate_initial_design_doc": "Design", "run_generate_design_doc_feedback": "Design", "collect_design_doc_human_feedback": "Design", "run_refine_design_doc": "Design", "collect_design_doc_decision": "Design", "run_select_uml_diagrams": "UML", "run_generate_initial_uml_codes": "UML", "run_generate_uml_feedback": "UML", "collect_uml_human_feedback": "UML", "run_refine_uml_codes": "UML", "collect_uml_decision": "UML", "run_generate_initial_code": "Code Generation", "collect_code_human_input": "Code Generation", "run_web_search_code": "Code Generation", "run_generate_code_feedback": "Code Generation", "collect_code_human_feedback": "Code Generation", "run_refine_code": "Code Generation", "collect_code_decision": "Code Generation", "run_code_review": "Review & Security", "run_security_check": "Review & Security", "merge_review_security_feedback": "Review & Security", "run_refine_code_with_reviews": "Review & Security", "collect_review_security_decision": "Review & Security", "run_generate_initial_test_cases": "Testing", "run_generate_test_cases_feedback": "Testing", "collect_test_cases_human_feedback": "Testing", "run_refine_test_cases_and_code": "Testing", "run_save_testing_outputs": "Testing", "run_generate_initial_quality_analysis": "Quality Analysis", "run_generate_quality_feedback": "Quality Analysis", "collect_quality_human_feedback": "Quality Analysis", "run_refine_quality_and_code": "Quality Analysis", "collect_quality_decision": "Quality Analysis", "generate_initial_deployment": "Deployment", "run_generate_initial_deployment": "Deployment", "run_generate_deployment_feedback": "Deployment", "collect_deployment_human_feedback": "Deployment", "run_refine_deployment": "Deployment", "collect_deployment_decision": "Deployment", "END": "END" }
+
+# --- Helper Functions ---
+def initialize_state():
+    """Initializes or resets the Streamlit session state."""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    default_project_folder = f"ai_sdlc_project_{timestamp}"
+    st.session_state.clear()
+    st.session_state.stage = "initial_setup"
+    st.session_state.workflow_state = {}
+    st.session_state.user_input = ""
+    st.session_state.display_content = "Welcome! Please configure API keys and project details to start."
+    st.session_state.project_folder_base = default_project_folder
+    st.session_state.current_prefs = ""
+    st.session_state.zip_path = None; st.session_state.review_code_zip_path = None; st.session_state.testing_code_zip_path = None; st.session_state.final_code_zip_path = None
+    # Configuration state
+    st.session_state.config_applied = False
+    st.session_state.selected_provider = LLM_PROVIDERS[0]
+    st.session_state.selected_model = AVAILABLE_MODELS[LLM_PROVIDERS[0]][0]
+    st.session_state.llm_api_key = ""
+    st.session_state.tavily_api_key = ""
+    st.session_state.llm_instance = None
+    st.session_state.tavily_instance = None
+    logger.info("Streamlit session state initialized.")
+
+def update_display(new_content: str):
+    st.session_state.display_content = new_content; logger.debug("Main display updated.")
+
+def create_download_button(file_path: str, label: str, mime: str, key_suffix: str, help_text: str = ""):
+    if not file_path or not isinstance(file_path, str): return
+    abs_file_path = os.path.abspath(file_path)
+    if os.path.exists(abs_file_path) and os.path.isfile(abs_file_path):
+        try:
+            with open(abs_file_path, "rb") as fp:
+                safe_label = "".join(c for c in label if c.isalnum())[:10]
+                button_key = f"dl_{key_suffix}_{safe_label}"
+                st.download_button(label=f"Download {label}", data=fp, file_name=os.path.basename(abs_file_path), mime=mime, key=button_key, help=help_text or f"Download {label}")
+        except FileNotFoundError: logger.warning(f"FileNotFound after check: {abs_file_path}")
+        except Exception as e: logger.error(f"Error prepping download btn for {abs_file_path}: {e}", exc_info=True); st.warning(f"DL Button error for {label}: {e}")
+
+def create_zip_and_download_button(folder_path_key: str, zip_path_key: str, zip_basename: str, button_label_prefix: str, sidebar_context):
+    folder_path = st.session_state.workflow_state.get(folder_path_key)
+    abs_folder_path = os.path.abspath(folder_path) if folder_path and isinstance(folder_path, str) else None
+    if abs_folder_path and os.path.exists(abs_folder_path) and os.path.isdir(abs_folder_path):
+        zip_label = f"Generate & Download {button_label_prefix} ZIP"
+        existing_zip = st.session_state.get(zip_path_key)
+        if existing_zip and os.path.exists(existing_zip): zip_label = f"Download {button_label_prefix} ZIP"
+        zip_gen_key = f"zip_gen_{zip_path_key}"
+        if sidebar_context.button(zip_label, key=zip_gen_key):
+            with st.spinner(f"Creating {button_label_prefix} archive..."):
+                try:
+                    out_dir = os.path.dirname(abs_folder_path); archive_base = os.path.join(out_dir, zip_basename)
+                    root_dir = os.path.dirname(abs_folder_path); base_dir = os.path.basename(abs_folder_path)
+                    logger.info(f"Zipping: base='{archive_base}', root='{root_dir}', dir='{base_dir}'")
+                    zip_file = archive_base + ".zip"
+                    if os.path.exists(zip_file): 
+                        try: os.remove(zip_file); logger.info(f"Removed old ZIP: {zip_file}") 
+                        except Exception as del_e: logger.warning(f"Could not remove old ZIP {zip_file}: {del_e}")
+                    archive_path = shutil.make_archive(base_name=archive_base, format='zip', root_dir=root_dir, base_dir=base_dir)
+                    if not os.path.exists(archive_path): raise OSError(f"ZIP not found after make_archive: {archive_path}")
+                    st.session_state[zip_path_key] = archive_path; st.success(f"{button_label_prefix} ZIP created!"); st.rerun()
+                except Exception as e: sidebar_context.error(f"ZIP Error: {e}"); logger.error(f"ZIP failed for '{abs_folder_path}': {e}", exc_info=True)
+        generated_zip = st.session_state.get(zip_path_key)
+        if generated_zip and os.path.exists(generated_zip):
+             try:
+                 with open(generated_zip, "rb") as fp:
+                     safe_prefix = "".join(c for c in button_label_prefix if c.isalnum())[:10]
+                     dl_key = f"dl_zip_{zip_path_key}_{safe_prefix}"
+                     sidebar_context.download_button(label=f"Download {button_label_prefix} ZIP", data=fp, file_name=os.path.basename(generated_zip), mime="application/zip", key=dl_key)
+             except Exception as e: sidebar_context.warning(f"Error reading ZIP: {e}"); logger.error(f"Error reading ZIP {generated_zip}: {e}", exc_info=True)
+
+# --- Initialization ---
+if 'stage' not in st.session_state:
+    initialize_state()
+
+# --- Sidebar UI ---
+with st.sidebar:
+    st.header("AI SDLC Orchestrator")
+    st.divider()
+
+    # --- Configuration Section ---
+    with st.expander("Configuration", expanded=not st.session_state.get('config_applied', False)):
+        st.subheader("LLM & API Keys")
+        selected_provider = st.selectbox("Select LLM Provider", options=LLM_PROVIDERS, key="selected_provider", help="Choose primary LLM provider.")
+        available_models = AVAILABLE_MODELS.get(selected_provider, ["N/A"])
+        selected_model = st.selectbox(f"Select Model ({selected_provider})", options=available_models, key="selected_model", help=f"Choose model from {selected_provider}.")
+        llm_api_key_input = st.text_input(f"{selected_provider} API Key", type="password", key="llm_api_key_input", help=f"Enter API key for {selected_provider}.", value=st.session_state.get("llm_api_key",""))
+        tavily_api_key_input = st.text_input("Tavily API Key (Optional)", type="password", key="tavily_api_key_input", help="Enter Tavily key for web search.", value=st.session_state.get("tavily_api_key",""))
+
+        if st.button("Apply Configuration", key="apply_config"):
+            with st.spinner("Initializing..."):
+                st.session_state.llm_api_key = llm_api_key_input # Update actual keys used
+                st.session_state.tavily_api_key = tavily_api_key_input
+                llm_inst, tav_inst, error_msg = SDLC.initialize_llm_clients(
+                    provider=st.session_state.selected_provider, model_name=st.session_state.selected_model,
+                    llm_api_key=st.session_state.llm_api_key, tavily_api_key=st.session_state.tavily_api_key
+                )
+                if llm_inst:
+                    st.session_state.llm_instance = llm_inst; st.session_state.tavily_instance = tav_inst; st.session_state.config_applied = True
+                    st.success("Configuration Applied!"); logger.info("LLM/Tavily configured via UI.")
+                    time.sleep(1); st.rerun() # Give time to see success, then rerun to potentially hide expander
+                else:
+                    st.session_state.config_applied = False; st.session_state.llm_instance = None; st.session_state.tavily_instance = None
+                    error_display = f"Config Failed: {error_msg or 'Unknown error.'}"; st.error(error_display); logger.error(error_display)
+    # --- END Configuration Section ---
+
+    st.divider()
+    st.header("Downloads"); st.caption("Generated artifacts and code snapshots.")
+    # Documents
+    st.markdown("---"); st.subheader("Documents")
+    create_download_button(st.session_state.workflow_state.get("final_user_story_path"), "User Story", "text/markdown", "us")
+    create_download_button(st.session_state.workflow_state.get("final_product_review_path"), "Product Review", "text/markdown", "pr")
+    create_download_button(st.session_state.workflow_state.get("final_design_document_path"), "Design Document", "text/markdown", "dd")
+    create_download_button(st.session_state.workflow_state.get("final_quality_analysis_path"), "QA Report", "text/markdown", "qa")
+    create_download_button(st.session_state.workflow_state.get("final_deployment_path"), "Deployment Plan", "text/markdown", "deploy")
+    # UML
+    st.markdown("---"); st.subheader("UML Diagrams")
+    uml_png_paths = st.session_state.workflow_state.get("final_uml_png_paths", []); uml_folder = st.session_state.workflow_state.get("final_uml_diagram_folder")
+    if uml_png_paths:
+        st.caption("Download PNG images:"); [create_download_button(p, f"UML: {'_'.join(os.path.basename(p).split('_')[2:]).replace('.png', '').replace('_', ' ').title() or f'Diagram {i+1}'}", "image/png", f"uml_{i}") for i, p in enumerate(uml_png_paths)]
+    elif uml_folder and os.path.exists(uml_folder): st.caption("*No PNGs generated/found.*")
+    else: st.caption("*UML diagrams not generated.*")
+    # Code Snapshots
+    st.markdown("---"); st.subheader("Code Snapshots (ZIP)"); st.caption("Code versions from key stages.")
+    create_zip_and_download_button("review_code_snapshot_folder", "review_code_zip_path", "code_snapshot_review", "Review Stage Code", st.sidebar)
+    create_zip_and_download_button("testing_passed_code_folder", "testing_code_zip_path", "code_snapshot_testing", "Testing Stage Code", st.sidebar)
+    create_zip_and_download_button("final_code_folder", "final_code_zip_path", "code_snapshot_final", "Final Code", st.sidebar)
+    st.divider()
+    # Final Project ZIP
+    if st.session_state.stage == "END":
+        st.markdown("**Full Project Archive**"); proj_folder = st.session_state.workflow_state.get("project_folder"); abs_proj = os.path.abspath(proj_folder) if proj_folder and isinstance(proj_folder, str) else None
+        if abs_proj and os.path.isdir(abs_proj):
+            zip_label = "Generate & Download Full Project ZIP";
+            if st.session_state.get("zip_path") and os.path.exists(st.session_state.zip_path): zip_label = "Download Full Project ZIP"
+            if st.sidebar.button(zip_label, key="zip_gen_final"):
+                with st.spinner("Creating full project archive..."):
+                    try:
+                        zip_base = os.path.abspath(st.session_state.project_folder_base); out_dir = os.path.dirname(zip_base); os.makedirs(out_dir, exist_ok=True)
+                        root_dir = os.path.dirname(abs_proj); base_dir = os.path.basename(abs_proj)
+                        logger.info(f"Zipping full project: base='{zip_base}', root='{root_dir}', dir='{base_dir}'")
+                        zip_file = zip_base + ".zip";
+                        if os.path.exists(zip_file): 
+                            try: os.remove(zip_file); logger.info(f"Removed old final ZIP: {zip_file}") 
+                            except Exception as del_e: logger.warning(f"Could not remove old final ZIP {zip_file}: {del_e}")
+                        archive_path = shutil.make_archive(base_name=zip_base, format='zip', root_dir=root_dir, base_dir=base_dir)
+                        if not os.path.exists(archive_path): raise OSError(f"Final ZIP failed: {archive_path} not found.")
+                        st.session_state.zip_path = archive_path; st.success(f"Full project ZIP created: {os.path.basename(archive_path)}"); st.rerun()
+                    except Exception as e: st.sidebar.error(f"Final ZIP Error: {e}"); logger.error(f"Final ZIP creation failed: {e}", exc_info=True)
+            if st.session_state.get("zip_path") and os.path.exists(st.session_state.zip_path):
+                 try:
+                     with open(st.session_state.zip_path, "rb") as fp: st.sidebar.download_button(label="Download Full Project ZIP", data=fp, file_name=os.path.basename(st.session_state.zip_path), mime="application/zip", key="dl_zip_final")
+                 except Exception as read_e: st.sidebar.warning(f"Error reading final ZIP: {read_e}"); logger.error(f"Error reading final ZIP {st.session_state.zip_path}: {read_e}", exc_info=True)
+        elif proj_folder: st.sidebar.warning(f"Project folder '{proj_folder}' not found.")
+        else: st.sidebar.caption("*Project folder undefined.*")
+    st.divider()
+    if st.sidebar.button("Restart Workflow", key="restart_sb", help="Clear progress and start over."):
+        logger.info("Workflow restart requested."); initialize_state(); st.rerun()
+
+# --- Main Layout & Controls ---
+main_col, indicator_col = st.columns([4, 1])
+input_needed = {"collect_answers", "collect_user_story_human_feedback", "collect_product_review_human_feedback", "collect_design_doc_human_feedback", "collect_uml_human_feedback", "collect_code_human_input", "collect_code_human_feedback", "merge_review_security_feedback", "collect_quality_human_feedback", "collect_deployment_human_feedback"}
+decision_needed = {"collect_user_story_decision", "collect_product_review_decision", "collect_design_doc_decision", "collect_uml_decision", "collect_code_decision", "collect_review_security_decision", "collect_quality_decision", "collect_deployment_decision"}
+current_stage = st.session_state.stage
+show_input_box = current_stage in input_needed; show_decision_btns = current_stage in decision_needed; show_test_fb = current_stage == "collect_test_cases_human_feedback"; show_setup_form = current_stage == "initial_setup"; show_deploy_prefs = current_stage == "generate_initial_deployment"
+
+with main_col:
+    st.header(f"Stage: {current_stage.replace('_', ' ').title()}")
+    st.markdown("### AI Output / Current Task:")
+    display_area = st.container(height=400, border=False)
+    with display_area: st.markdown(str(st.session_state.get("display_content", "Initializing...")), unsafe_allow_html=False)
+    st.divider()
+
+    # --- GATING ---
+    if not st.session_state.get('config_applied', False):
+        st.warning("👈 Please configure LLM Provider & API Keys in the sidebar first.")
+    else:
+        # --- Workflow UI ---
+        if show_setup_form:
+            with st.form("setup_form"):
+                st.markdown("### Project Configuration")
+                proj_folder = st.text_input("Project Folder Name", value=st.session_state.project_folder_base, help="Directory name. No spaces/special chars.")
+                proj_name = st.text_input("Project Description", value="Web Task Manager Example")
+                proj_cat = st.text_input("Category", value="Web Development")
+                proj_subcat = st.text_input("Subcategory", value="Productivity Tool")
+                proj_lang = st.text_input("Coding Language", value="Python")
+                min_iter = st.number_input("Min Q&A Rounds", 1, 5, 2)
+                submitted = st.form_submit_button("Start Workflow")
+                if submitted:
+                    if not all([proj_folder, proj_name, proj_cat, proj_subcat, proj_lang]): st.error("Fill all fields.")
+                    elif any(c in proj_folder for c in r'/\:*?"<>| '): st.error("Invalid chars in folder name.")
+                    else:
+                        try:
+                            abs_proj = os.path.abspath(proj_folder)
+                            if os.path.exists(abs_proj) and not os.path.isdir(abs_proj): st.error(f"File exists: '{proj_folder}'.")
+                            else:
+                                if os.path.exists(abs_proj): st.warning(f"Folder exists: '{abs_proj}'.")
+                                else: os.makedirs(abs_proj, exist_ok=True); st.success(f"Folder ready: '{abs_proj}'")
+                                # Initialize state including LLM/Tavily instances
+                                initial_workflow_state = { "llm_instance": st.session_state.llm_instance, "tavily_instance": st.session_state.tavily_instance, "messages": [SDLC.HumanMessage(content=f"Setup:\nProject:{proj_name}\nCat:{proj_cat}\nSub:{proj_subcat}\nLang:{proj_lang}")], "project_folder": proj_folder, "project": proj_name, "category": proj_cat, "subcategory": proj_subcat, "coding_language": proj_lang, "user_input_iteration": 0, "user_input_min_iterations": min_iter, **{k: None for k in SDLC.MainState.__annotations__ if k not in ["llm_instance", "tavily_instance", "messages", "project_folder", "project", "category", "subcategory", "coding_language", "user_input_iteration", "user_input_min_iterations"]}, "user_input_questions": [], "user_input_answers": [], "user_input_done": False, "final_uml_codes": [], "final_code_files": [], "final_test_code_files": [], "test_cases_current": [], "uml_selected_diagrams": [], "uml_current_codes": [], "uml_feedback": {}, "uml_human_feedback": {}, "final_uml_png_paths": [], "code_current": SDLC.GeneratedCode(files=[], instructions=""), "user_story_done": False, "product_review_done": False, "design_doc_done": False, "uml_done": False, "code_done": False, "review_security_done": False, "test_cases_passed": False, "quality_done": False, "deployment_done": False }
+                                st.session_state.workflow_state = initial_workflow_state; st.session_state.project_folder_base = proj_folder; st.session_state.stage = "run_generate_questions"; logger.info(f"Setup complete. Starting workflow for '{proj_name}'."); st.rerun()
+                        except OSError as oe: st.error(f"Folder error '{proj_folder}': {oe}."); logger.error(f"OSError creating folder: {oe}", exc_info=True)
+                        except Exception as e: st.error(f"Setup error: {e}"); logger.error(f"Setup error: {e}", exc_info=True)
+
+        elif show_deploy_prefs:
+             with st.form("deploy_prefs_form"):
+                 st.markdown("### Deployment Preferences"); st.info("Specify target environment.")
+                 deploy_target = st.selectbox("Target", ["Localhost", "Docker", "AWS EC2", "AWS Lambda", "GCP Run", "Azure App Service", "Other"], key="deploy_target")
+                 deploy_details = st.text_area("Details:", height=100, key="deploy_details", placeholder="e.g., AWS region, Nginx, DB connection")
+                 submitted = st.form_submit_button("Generate Plan")
+                 if submitted: prefs = f"Target: {deploy_target}\nDetails: {deploy_details}"; st.session_state.current_prefs = prefs; st.session_state.stage = "run_generate_initial_deployment"; logger.info(f"Deploy prefs: {deploy_target}"); st.rerun()
+
+        elif show_input_box:
+            input_key = f"input_{current_stage}"; user_val = st.text_area("Input / Feedback:", height=150, key=input_key, value=st.session_state.get('user_input', ''), help="Provide feedback/answers. For Q&A, use #DONE when finished.")
+            submit_key = f"submit_{current_stage}"
+            if st.button("Submit", key=submit_key):
+                user_text = user_val.strip(); state = st.session_state.workflow_state
+                if not isinstance(state, dict): st.error("State invalid."); logger.critical("workflow_state invalid."); initialize_state(); st.rerun()
+                try:
+                    next_stage = None; state['messages'] = state.get('messages', [])
+                    map = { "collect_answers": ("user_input_answers", "run_generate_questions", True), "collect_user_story_human_feedback": ("user_story_human_feedback", "run_refine_user_stories", False), "collect_product_review_human_feedback": ("product_review_human_feedback", "run_refine_product_review", False), "collect_design_doc_human_feedback": ("design_doc_human_feedback", "run_refine_design_doc", False), "collect_uml_human_feedback": ("uml_human_feedback", "run_refine_uml_codes", False), "collect_code_human_input": ("code_human_input", "run_web_search_code", False), "collect_code_human_feedback": ("code_human_feedback", "run_refine_code", False), "merge_review_security_feedback": ("review_security_human_feedback", "run_refine_code_with_reviews", False), "collect_quality_human_feedback": ("quality_human_feedback", "run_refine_quality_and_code", False), "collect_deployment_human_feedback": ("deployment_human_feedback", "run_refine_deployment", False) }
+                    if current_stage in map:
+                        key, next_run, is_list = map[current_stage]
+                        if is_list: state[key] = state.get(key, []) + [user_text]
+                        elif key == "uml_human_feedback": state[key] = {"all": user_text}
+                        else: state[key] = user_text
+                        state["messages"].append(SDLC.HumanMessage(content=user_text)); next_stage = next_run
+                        if current_stage == "collect_answers":
+                            state["user_input_iteration"] = state.get("user_input_iteration", 0) + 1; min_i = state.get("user_input_min_iterations", 1)
+                            lines = [l for l in user_text.splitlines() if l.strip()]; last = lines[-1].strip().upper() if lines else ""; done = "#DONE" in last
+                            logger.debug(f"Q&A Iter:{state['user_input_iteration']}/{min_i}. Done:{done}")
+                            if state["user_input_iteration"] >= min_i and done: state["user_input_done"] = True; next_stage = "run_refine_prompt"; logger.info("Q&A done.")
+                            else: state["user_input_done"] = False; logger.info("Continuing Q&A.")
+                        if current_stage == "collect_code_human_input" and not state.get('tavily_instance'): state["code_web_search_results"] = "Skipped (Tavily N/A)"; next_stage = "run_generate_code_feedback"; logger.info("Skipping web search.")
+                    else: st.error(f"Input logic undefined: {current_stage}"); logger.error(f"Input logic missing: {current_stage}")
+                    if next_stage: st.session_state.workflow_state = state; st.session_state.user_input = ""; st.session_state.stage = next_stage; logger.info(f"Input '{current_stage}'. -> '{next_stage}'."); st.rerun()
+                except Exception as e: st.error(f"Input error: {e}"); logger.error(f"Input error {current_stage}: {e}", exc_info=True)
+
+        elif show_test_fb:
+            st.markdown("### Test Execution & Feedback"); st.info("Execute tests, provide feedback & outcome.")
+            ai_fb = st.session_state.workflow_state.get("test_cases_feedback", "*N/A*")
+            with st.expander("AI Feedback on Tests"): st.markdown(ai_fb)
+            human_fb = st.text_area("Feedback & Results:", height=150, key="tc_fb")
+            pf_status = st.radio("Core Tests Passed?", ("PASS", "FAIL"), index=1, key="tc_pf", horizontal=True)
+            c1, c2 = st.columns(2)
+            with c1: # Submit Results
+                if st.button("Submit Results", key="submit_test"):
+                    state = st.session_state.workflow_state; state['messages'] = state.get('messages', [])
+                    fb = f"Res: {pf_status}\nFB:{human_fb}"; state["test_cases_human_feedback"] = fb; state["test_cases_passed"] = (pf_status == "PASS")
+                    state["messages"].append(SDLC.HumanMessage(content=fb)); logger.info(f"Test res: {pf_status}.")
+                    next_s = "run_save_testing_outputs" if state["test_cases_passed"] else "run_refine_test_cases_and_code"
+                    st.session_state.stage = next_s; st.session_state.workflow_state = state; st.rerun()
+            with c2: # Regen Code
+                if st.button("Submit & Regenerate Code", key="regen_test"):
+                    state = st.session_state.workflow_state; state['messages'] = state.get('messages', [])
+                    fb = f"Res: {pf_status}\nFB:{human_fb}\nDecision: Regen Code."; state["test_cases_human_feedback"] = fb; state["test_cases_passed"] = False
+                    state["messages"].append(SDLC.HumanMessage(content=fb)); logger.info(f"Test FB ({pf_status}), regen code.")
+                    ctx = f"From Testing:\nRes:{pf_status}\nFB:{human_fb}\nAI Test FB:{ai_fb}\nRegen code.";
+                    state["code_human_input"] = ctx; state["messages"].append(SDLC.HumanMessage(content=f"Regen Context: {ctx[:200]}..."))
+                    st.session_state.stage = "collect_code_human_input"; st.session_state.workflow_state = state; st.rerun()
+
+        elif show_decision_btns:
+            st.markdown("### Decision Point"); st.info("Review output. Refine or proceed.")
+            refine_map = { "collect_user_story_decision": "run_generate_user_story_feedback", "collect_product_review_decision": "run_generate_product_review_feedback", "collect_design_doc_decision": "run_generate_design_doc_feedback", "collect_uml_decision": "run_generate_uml_feedback", "collect_code_decision": "collect_code_human_input", "collect_review_security_decision": "run_code_review", "collect_quality_decision": "run_generate_quality_feedback", "collect_deployment_decision": "run_generate_deployment_feedback", }
+            proceed_map = { "collect_user_story_decision": ("user_story_done", SDLC.save_final_user_story, "run_generate_initial_product_review"), "collect_product_review_decision": ("product_review_done", SDLC.save_final_product_review, "run_generate_initial_design_doc"), "collect_design_doc_decision": ("design_doc_done", SDLC.save_final_design_doc, "run_select_uml_diagrams"), "collect_uml_decision": ("uml_done", SDLC.save_final_uml_diagrams, "run_generate_initial_code"), "collect_code_decision": ("code_done", None, "run_code_review"), "collect_review_security_decision": ("review_security_done", SDLC.save_review_security_outputs, "run_generate_initial_test_cases"), "collect_quality_decision": ("quality_done", SDLC.save_final_quality_analysis, "generate_initial_deployment"), "collect_deployment_decision": ("deployment_done", SDLC.save_final_deployment_plan, "END"), }
+            cols = st.columns(3 if current_stage == "collect_quality_decision" else 2)
+            with cols[0]: # Refine
+                if st.button("Refine", key=f"refine_{current_stage}"):
+                    if current_stage in refine_map: state = st.session_state.workflow_state; done_key = current_stage.replace("collect_", "").replace("_decision", "_done"); state[done_key]=False; next_refine = refine_map[current_stage]; st.session_state.stage = next_refine; st.session_state.workflow_state = state; logger.info(f"Decision: Refine '{current_stage}'. -> '{next_refine}'."); st.rerun()
+                    else: st.warning("Refine undefined."); logger.warning(f"Refine undefined for {current_stage}")
+            with cols[1]: # Proceed
+                if st.button("Proceed", key=f"proceed_{current_stage}"):
+                    if current_stage in proceed_map:
+                        state = st.session_state.workflow_state; done_key, save_func, next_stage = proceed_map[current_stage]; err = False
+                        try:
+                            state[done_key] = True; logger.info(f"Decision: Proceed from '{current_stage}'. Marked '{done_key}'=True.")
+                            if current_stage == "collect_code_decision": # Promote code
+                                 code_obj = state.get("code_current");
+                                 if code_obj and isinstance(code_obj, SDLC.GeneratedCode) and code_obj.files: state["final_code_files"] = code_obj.files; logger.info(f"Promoted {len(code_obj.files)} files.")
+                                 else: st.warning("Proceed code gen, but 'code_current' invalid."); logger.warning("Proceed code gen, invalid."); state["final_code_files"] = []
+                            if save_func: # Save artifact
+                                fn = getattr(save_func, '__name__', 'save_func'); logger.info(f"Saving: {fn}")
+                                with st.spinner(f"Saving..."): state = save_func(state); st.session_state.workflow_state = state
+                                # Post-save check (basic)
+                                map_paths = { SDLC.save_final_user_story: "final_user_story_path", SDLC.save_final_product_review: "final_product_review_path", SDLC.save_final_design_doc: "final_design_document_path", SDLC.save_final_uml_diagrams: "final_uml_diagram_folder", SDLC.save_review_security_outputs: "final_review_security_folder", SDLC.save_testing_outputs: "final_testing_folder", SDLC.save_final_quality_analysis: "final_quality_analysis_path", SDLC.save_final_deployment_plan: "final_deployment_path", }; path_key = map_paths.get(save_func); path_val = state.get(path_key) if path_key else True; qa_ok = True if save_func != SDLC.save_final_quality_analysis else bool(state.get("final_code_folder"))
+                                if (path_key and not path_val) or not qa_ok: st.warning(f"Saving for '{current_stage}' may have failed."); logger.warning(f"Save check failed for {fn}.")
+                                else: logger.info(f"Save {fn} ok.")
+                        except Exception as e: st.error(f"Finalize error '{current_stage}': {e}"); logger.error(f"Proceed error {current_stage}: {e}", exc_info=True); err = True
+                        if not err: st.session_state.stage = next_stage; logger.info(f"-> {next_stage}"); st.rerun()
+                    else: st.warning("Proceed undefined."); logger.warning(f"Proceed undefined for {current_stage}")
+            if current_stage == "collect_quality_decision": # QA Regen
+                with cols[2]:
+                    if st.button("Regen Code", key="regen_qa"):
+                        state = st.session_state.workflow_state; state['messages'] = state.get('messages', []); logger.info("Decision: Regen Code from QA.")
+                        qa_sum = state.get('quality_current_analysis', 'N/A')[:1000]
+                        ctx = f"From QA:\nFindings:\n{qa_sum}...\nRegen code."; state["code_human_input"] = ctx; state["messages"].append(SDLC.HumanMessage(content=f"Regen Context: {ctx[:200]}..."))
+                        st.session_state.stage = "collect_code_human_input"; st.session_state.workflow_state = state; st.rerun()
+
+        elif current_stage == "END":
+            st.balloons(); final_msg = "## Workflow Completed!\n\nUse sidebar downloads or restart."; update_display(final_msg); st.markdown(final_msg); logger.info("Workflow END.")
+        elif not current_stage.startswith("run_"): st.error(f"Unknown UI stage: '{current_stage}'. Restart?"); logger.error(f"Unknown UI stage: {current_stage}")
+
+# --- Cycle Indicator ---
+with indicator_col:
+    st.subheader("Workflow Cycles")
+    current_major = STAGE_TO_CYCLE.get(current_stage, "Unknown"); current_idx = -1
+    if current_major in CYCLE_ORDER: current_idx = CYCLE_ORDER.index(current_major)
+    elif current_major == "END": current_idx = len(CYCLE_ORDER)
+    st.markdown("""<style>.cycle-item { margin-bottom: 0.75em; transition: all 0.3s ease-in-out; padding: 4px 0; } .cycle-past { opacity: 0.4; font-size: 0.9em; padding-left: 15px; border-left: 4px solid #ccc; } .cycle-current { font-weight: bold; font-size: 1.1em; color: #008080; border-left: 4px solid #008080; padding-left: 11px;} .cycle-future { opacity: 0.7; font-size: 0.95em; padding-left: 15px; border-left: 4px solid #eee; } .cycle-end { font-weight: bold; font-size: 1.0em; color: #4CAF50; border-left: 4px solid #4CAF50; padding-left: 11px; }</style>""", unsafe_allow_html=True)
+    win_before, win_after = 2, 4; start = max(0, current_idx - win_before); end = min(len(CYCLE_ORDER), start + win_before + win_after); start = max(0, end - (win_before + win_after))
+    for i, name in enumerate(CYCLE_ORDER):
+        if start <= i < end :
+            css = "cycle-item"; display = name
+            if i < current_idx: css += " cycle-past"
+            elif i == current_idx and current_major != "END": css += " cycle-current"; display = f"➡️ {name}"
+            else: css += " cycle-future"
+            st.markdown(f'<div class="{css}">{display}</div>', unsafe_allow_html=True)
+    if current_major == "END": st.markdown(f'<div class="cycle-item cycle-end">✅ Workflow End</div>', unsafe_allow_html=True)
+
+# --- Invisible Stages Logic ---
+# --- CORRECTED run_workflow_step function for app.py ---
+
+def run_workflow_step(func, next_display_stage, *args):
+    """
+    Executes a backend workflow function, updates state and display content,
+    and transitions to the next appropriate UI stage.
+    """
+    state = st.session_state.workflow_state
+    # Ensure state is a dictionary before proceeding
+    if not isinstance(state, dict):
+        st.error("Critical Error: workflow_state is invalid. Restarting.")
+        logger.critical("run_workflow_step called with invalid state type. Forcing restart.")
+        initialize_state(); st.rerun(); return
+
+    func_name = getattr(func, '__name__', repr(func))
+    # Handle specific case for lambda function name used in deployment
+    if func_name == '<lambda>' and next_display_stage == "run_generate_deployment_feedback":
+        func_name = "generate_initial_deployment"
+
+    logger.info(f"Attempting to run workflow function: {func_name}")
+
+    try:
+        # Show spinner during execution
+        spinner_message = f"Running: {func_name.replace('_',' ').title()}..."
+        with st.spinner(spinner_message):
+            # --- Check for LLM instance before calling ---
+            # List of functions that DON'T require an LLM instance
+            non_llm_funcs = {
+                SDLC.save_final_user_story, SDLC.save_final_product_review,
+                SDLC.save_final_design_doc, SDLC.save_final_uml_diagrams,
+                SDLC.save_review_security_outputs, SDLC.save_testing_outputs,
+                SDLC.save_final_quality_analysis, SDLC.save_final_deployment_plan,
+                SDLC.web_search_code # web_search_code checks internally for tavily instance
+            }
+            if func not in non_llm_funcs and not state.get('llm_instance'):
+                raise ConnectionError("LLM is not configured or initialized in the current state.")
+
+            # --- Check for Tavily if function needs it ---
+            if func == SDLC.web_search_code and not state.get('tavily_instance'):
+                 logger.warning("Web search called but Tavily instance not found in state. Skipping.")
+                 # Update state to reflect skipped search and proceed
+                 state["code_web_search_results"] = "Skipped (Tavily client not configured/initialized in state)"
+                 if 'messages' not in state: state['messages'] = []
+                 state["messages"].append(AIMessage(content="Web Search: Skipped (Tavily not available in state)"))
+                 st.session_state.workflow_state = state
+                 # IMPORTANT: Determine the correct next stage if web search is skipped
+                 # In the map, run_web_search_code -> run_generate_code_feedback
+                 # So, we directly set the next_display_stage to that
+                 st.session_state.stage = "run_generate_code_feedback"
+                 logger.info("Skipping web search, directly transitioning to 'run_generate_code_feedback'")
+                 st.rerun()
+                 return # Stop this execution
+
+            # Special handling for review -> security chain
+            if func == SDLC.code_review:
+                 logger.info("Executing code review step...")
+                 state = SDLC.code_review(state) # Call the review function
+                 st.session_state.workflow_state = state # Update state immediately
+                 st.session_state.stage = "run_security_check" # Set next internal stage
+                 logger.info("Code review complete, triggering security check immediately.")
+                 st.rerun() # Rerun to execute the security check step defined in workflow_map
+                 return # Stop current function execution here
+
+            # Normal execution
+            updated_state = func(state, *args)
+
+        # Ensure the function returned a dictionary (the updated state)
+        if not isinstance(updated_state, dict):
+             logger.error(f"Function {func_name} did not return a dictionary state. Returned type: {type(updated_state)}")
+             st.error(f"Workflow Error: Step '{func_name}' failed internally (invalid return type).")
+             return # Avoid proceeding with invalid state
+
+        st.session_state.workflow_state = updated_state; logger.debug(f"State updated after {func_name}.")
+
+        # --- Determine Display Content based on the completed step ---
+        # Default fallback message
+        display_text = f"Completed: {func_name}. Preparing next step..."
+
+        # --- FULL if/elif block for customizing display_text ---
+        if func == SDLC.generate_questions:
+            questions = updated_state.get("user_input_questions", [])
+            num_q = len(questions); start_index = max(0, num_q - 5)
+            latest_questions = questions[start_index:]
+            if latest_questions:
+                min_iter = updated_state.get('user_input_min_iterations', 1)
+                current_iter = updated_state.get("user_input_iteration", 0) # Iteration count is updated *after* answer submission
+                min_iter_msg = f"(Minimum {min_iter} rounds required)" if current_iter < min_iter else ""
+                display_text = f"Please answer the following questions {min_iter_msg}:\n\n" + "\n".join(f"- {q}" for q in latest_questions)
+                if current_iter + 1 >= min_iter: # Check if *next* iteration meets minimum
+                     display_text += "\n\n*Type '#DONE' on the last line when finished.*"
+            else:
+                # Handle case where LLM returns no questions (e.g., if requirements clear)
+                display_text = "AI indicates requirements may be clear. Proceeding to refine prompt..."
+                # Force transition if no questions were generated unexpectedly
+                next_display_stage = "run_refine_prompt"
+
+        elif func == SDLC.refine_prompt:
+            display_text = "**Refined Project Prompt:**\n\n```\n{}\n```\n\n*Proceeding to generate User Stories...*".format(updated_state.get('refined_prompt', 'N/A'))
+
+        elif func in [SDLC.generate_initial_user_stories, SDLC.refine_user_stories]:
+            us_current = updated_state.get('user_story_current', 'N/A')
+            display_text = f"**Current User Stories:**\n\n{us_current}" # Use markdown directly if it contains formatting
+            if func == SDLC.refine_user_stories:
+                 display_text += "\n\n*Please review the refined stories and decide whether to refine further or proceed.*"
+                 next_display_stage = "collect_user_story_decision" # Correct next stage after refinement
+            else:
+                 display_text += "\n\n*Generating AI feedback on these stories...*"
+                 # next_display_stage remains as passed ("run_generate_user_story_feedback")
+
+        elif func == SDLC.generate_user_story_feedback:
+            feedback = updated_state.get('user_story_feedback', 'N/A')
+            display_text = f"**AI Feedback (User Stories):**\n\n{feedback}\n\n*Please provide your feedback on the stories and the AI's assessment.*"
+
+        elif func in [SDLC.generate_initial_product_review, SDLC.refine_product_review]:
+            review_current = updated_state.get('product_review_current', 'N/A')
+            display_text = f"**Current Product Review:**\n\n{review_current}"
+            if func == SDLC.refine_product_review:
+                 display_text += "\n\n*Please review the refined PO review and decide whether to refine further or proceed.*"
+                 next_display_stage = "collect_product_review_decision"
+            else:
+                 display_text += "\n\n*Generating AI feedback on this review...*"
+
+        elif func == SDLC.generate_product_review_feedback:
+            feedback = updated_state.get('product_review_feedback', 'N/A')
+            display_text = f"**AI Feedback (Product Review):**\n\n{feedback}\n\n*Please provide your feedback on the review and the AI's assessment.*"
+
+        elif func in [SDLC.generate_initial_design_doc, SDLC.refine_design_doc]:
+            doc_current = updated_state.get('design_doc_current', 'N/A')
+            display_text = f"**Current Design Document:**\n\n{doc_current}"
+            if func == SDLC.refine_design_doc:
+                 display_text += "\n\n*Please review the refined design document and decide whether to refine further or proceed.*"
+                 next_display_stage = "collect_design_doc_decision"
+            else:
+                 display_text += "\n\n*Generating AI feedback on this design...*"
+
+        elif func == SDLC.generate_design_doc_feedback:
+            feedback = updated_state.get('design_doc_feedback', 'N/A')
+            display_text = f"**AI Feedback (Design Doc):**\n\n{feedback}\n\n*Please provide your feedback on the design and the AI's assessment.*"
+
+        elif func == SDLC.select_uml_diagrams:
+            selected = updated_state.get('uml_selected_diagrams', [])
+            messages = updated_state.get('messages', [])
+            justification_msg = messages[-1].content if messages else "Selection complete." # Try to get justification from last msg
+            display_text = f"**Selected UML Diagram Types:**\n\n{justification_msg}\n\n*Generating initial diagrams...*"
+
+        elif func in [SDLC.generate_initial_uml_codes, SDLC.refine_uml_codes]:
+            codes = updated_state.get('uml_current_codes', [])
+            codes_display = "\n\n".join([f"**{c.diagram_type}**:\n```plantuml\n{c.code}\n```" for c in codes])
+            status = "Refined" if func == SDLC.refine_uml_codes else "Generated"
+            display_text = f"**{status} UML Codes:**\n\n{codes_display}"
+            if func == SDLC.refine_uml_codes:
+                 display_text += "\n\n*Please review the refined diagrams and decide whether to refine further or proceed.*"
+                 next_display_stage = "collect_uml_decision"
+            else:
+                 display_text += "\n\n*Generating AI feedback on these diagrams...*"
+
+        elif func == SDLC.generate_uml_feedback:
+            feedback_dict = updated_state.get('uml_feedback', {})
+            feedback_display = "\n\n".join([f"**Feedback for {dt}:**\n{fb}" for dt, fb in feedback_dict.items()])
+            display_text = f"**AI Feedback on UML Diagrams:**\n\n{feedback_display}\n\n*Please provide your overall feedback on the diagrams and the AI assessment.*"
+
+        elif func in [SDLC.generate_initial_code, SDLC.refine_code, SDLC.refine_code_with_reviews]:
+             code_data = updated_state.get("code_current")
+             stage_desc = "Initial" if func == SDLC.generate_initial_code else "Refined"
+             if code_data and isinstance(code_data, SDLC.GeneratedCode):
+                 files_display=[]; total_len, max_len = 0, 3000
+                 for f in code_data.files:
+                     s=f.content[:max_len-total_len]; file_disp = f"**{f.filename}**:\n```\n{s}{'...' if len(f.content) > len(s) else ''}\n```"
+                     files_display.append(file_disp); total_len += len(s) + len(f.filename)
+                     if total_len >= max_len: files_display.append("\n*... (Code truncated)*"); break
+                 num_files = len(code_data.files); instr = code_data.instructions
+                 display_text = f"**{stage_desc} Code ({num_files} files):**\n{''.join(files_display)}\n\n**Setup/Run:**\n```\n{instr}\n```"
+                 if func == SDLC.generate_initial_code: display_text += "\n\n*Attempt run & provide feedback.*"; next_display_stage = "collect_code_human_input"
+                 elif func == SDLC.refine_code: display_text += "\n\n*Review refined code.*"; next_display_stage = "collect_code_decision"
+                 elif func == SDLC.refine_code_with_reviews: display_text += "\n\n*Review code refined post-review.*"; next_display_stage = "collect_review_security_decision"
+             else: display_text = f"{stage_desc} code step done, but no valid code data."; logger.error(f"{func_name} invalid code data.")
+
+        elif func == SDLC.web_search_code:
+            results = updated_state.get('code_web_search_results', 'N/A')
+            display_text = f"**Web Search Results:**\n\n{results}\n\n*Generating AI feedback...*"
+
+        elif func == SDLC.generate_code_feedback:
+            feedback = updated_state.get('code_feedback', 'N/A')
+            display_text = f"**AI Code Feedback:**\n\n{feedback}\n\n*Please provide your comments.*"
+
+        elif func == SDLC.security_check: # Display after review->sec chain
+             review_fb = updated_state.get('code_review_current_feedback', 'N/A'); security_fb = updated_state.get('security_current_feedback', 'N/A')
+             display_text=f"**Code Review:**\n```\n{review_fb}\n```\n\n**Security Check:**\n```\n{security_fb}\n```\n\n*Provide overall feedback.*"
+
+        elif func == SDLC.generate_initial_test_cases:
+             tests = updated_state.get('test_cases_current', [])
+             tests_d = "\n\n".join([f"**{tc.description}**:\n  - In:`{tc.input_data}`\n  - Exp:`{tc.expected_output}`" for tc in tests])
+             display_text=f"**Generated Tests ({len(tests)}):**\n\n{tests_d}\n\n*Generating AI feedback...*"
+
+        elif func == SDLC.generate_test_cases_feedback:
+            feedback = updated_state.get('test_cases_feedback', 'N/A')
+            display_text=f"**AI Test Case Feedback:**\n\n{feedback}\n\n*Execute tests & provide results.*"
+
+        elif func == SDLC.refine_test_cases_and_code:
+            tests = updated_state.get('test_cases_current', []); files_count = len(updated_state.get('final_code_files', []))
+            tests_d = "\n\n".join([f"**{tc.description}**:\n  - In:`{tc.input_data}`\n  - Exp:`{tc.expected_output}`" for tc in tests])
+            display_text = f"**Refined Tests & Code ({files_count} files):**\n\n*Code/tests updated.*\n\n**Refined Tests ({len(tests)}):**\n{tests_d}\n\n*Execute tests again.*"
+            next_display_stage = "collect_test_cases_human_feedback" # Always collect feedback after refine
+
+        elif func == SDLC.save_testing_outputs:
+             display_text = f"Test results saved (PASS). Generating QA report..."
+             # next_display_stage remains as passed ("run_generate_initial_quality_analysis")
+
+        elif func in [SDLC.generate_initial_quality_analysis, SDLC.refine_quality_and_code]:
+            report = updated_state.get('quality_current_analysis', 'N/A')
+            display_text=f"**Quality Analysis Report:**\n\n{report}"
+            if func == SDLC.refine_quality_and_code: display_text += "\n\n*Review refined QA report.*"; next_display_stage = "collect_quality_decision"
+            else: display_text += "\n\n*Generating AI feedback...*"
+
+        elif func == SDLC.generate_quality_feedback:
+            feedback = updated_state.get('quality_feedback', 'N/A')
+            display_text=f"**AI Feedback on QA Report:**\n\n{feedback}\n\n*Provide your feedback.*"
+
+        elif func_name == "generate_initial_deployment": # Handle lambda
+             plan = updated_state.get('deployment_current_process', 'N/A')
+             display_text = f"**Initial Deployment Plan:**\n```\n{plan}\n```\n\n*Generating AI feedback...*"
+             # next_display_stage remains as passed ("run_generate_deployment_feedback")
+
+        elif func == SDLC.refine_deployment:
+             plan = updated_state.get('deployment_current_process', 'N/A')
+             display_text = f"**Refined Deployment Plan:**\n```\n{plan}\n```\n\n*Review refined plan.*"
+             next_display_stage = "collect_deployment_decision"
+
+        elif func == SDLC.generate_deployment_feedback:
+            feedback = updated_state.get('deployment_feedback', 'N/A')
+            display_text=f"**AI Feedback on Deployment Plan:**\n\n{feedback}\n\n*Provide your feedback.*"
+
+        # Handle Save Functions (Generic Message)
+        elif func in [SDLC.save_final_user_story, SDLC.save_final_product_review, SDLC.save_final_design_doc, SDLC.save_final_uml_diagrams, SDLC.save_review_security_outputs, SDLC.save_testing_outputs, SDLC.save_final_quality_analysis, SDLC.save_final_deployment_plan]:
+            artifact_name = func.__name__.replace('save_final_','').replace('_',' ')
+            # Use the next_display_stage passed into the function
+            next_action_stage_name = next_display_stage
+            next_action_desc = STAGE_TO_CYCLE.get(next_action_stage_name, next_action_stage_name).replace('_',' ').title()
+            if next_action_stage_name == "generate_initial_deployment": next_action_desc = "Deployment Preferences"
+            elif next_action_stage_name == "END": next_action_desc = "Workflow Completion"
+            display_text = f"Saved {artifact_name}. Starting next: {next_action_desc}..."
+            logger.info(f"Artifact saved: {artifact_name}. Next: {next_action_desc}")
+        # --- END FULL DISPLAY MAPPING ---
+
+        # --- Update display content and transition ---
+        update_display(display_text)
+        st.session_state.stage = next_display_stage
+        logger.info(f"Workflow function '{func_name}' completed. Transitioning UI to stage: '{next_display_stage}'")
+        st.rerun() # Refresh the UI
+
+    except ConnectionError as ce:
+        error_msg = f"Connection Error during '{func_name}': {ce}. Check API keys/network. Workflow stopped."
+        st.error(error_msg); logger.critical(error_msg, exc_info=True); st.stop()
+    except Exception as e:
+        error_msg = f"Error during step '{func_name}': {e}"
+        st.error(error_msg); logger.error(f"Error executing {func_name}: {e}", exc_info=True)
+        retry_key = f"retry_{func_name}_{int(time.time())}"
+        if st.button("Retry Last Step", key=retry_key): logger.info(f"User retry: {func_name}"); st.rerun()
+
+# --- Workflow Map Definition (No change) ---
+workflow_map = { "run_generate_questions": (SDLC.generate_questions, "collect_answers"), "run_refine_prompt": (SDLC.refine_prompt, "run_generate_initial_user_stories"), "run_generate_initial_user_stories": (SDLC.generate_initial_user_stories, "run_generate_user_story_feedback"), "run_generate_user_story_feedback": (SDLC.generate_user_story_feedback, "collect_user_story_human_feedback"), "run_refine_user_stories": (SDLC.refine_user_stories, "collect_user_story_decision"), "run_generate_initial_product_review": (SDLC.generate_initial_product_review, "run_generate_product_review_feedback"), "run_generate_product_review_feedback": (SDLC.generate_product_review_feedback, "collect_product_review_human_feedback"), "run_refine_product_review": (SDLC.refine_product_review, "collect_product_review_decision"), "run_generate_initial_design_doc": (SDLC.generate_initial_design_doc, "run_generate_design_doc_feedback"), "run_generate_design_doc_feedback": (SDLC.generate_design_doc_feedback, "collect_design_doc_human_feedback"), "run_refine_design_doc": (SDLC.refine_design_doc, "collect_design_doc_decision"), "run_select_uml_diagrams": (SDLC.select_uml_diagrams, "run_generate_initial_uml_codes"), "run_generate_initial_uml_codes": (SDLC.generate_initial_uml_codes, "run_generate_uml_feedback"), "run_generate_uml_feedback": (SDLC.generate_uml_feedback, "collect_uml_human_feedback"), "run_refine_uml_codes": (SDLC.refine_uml_codes, "collect_uml_decision"), "run_generate_initial_code": (SDLC.generate_initial_code, "collect_code_human_input"), "run_web_search_code": (SDLC.web_search_code, "run_generate_code_feedback"), "run_generate_code_feedback": (SDLC.generate_code_feedback, "collect_code_human_feedback"), "run_refine_code": (SDLC.refine_code, "collect_code_decision"), "run_code_review": (SDLC.code_review, "run_security_check"), "run_security_check": (SDLC.security_check, "merge_review_security_feedback"), "run_refine_code_with_reviews": (SDLC.refine_code_with_reviews, "collect_review_security_decision"), "run_generate_initial_test_cases": (SDLC.generate_initial_test_cases, "run_generate_test_cases_feedback"), "run_generate_test_cases_feedback": (SDLC.generate_test_cases_feedback, "collect_test_cases_human_feedback"), "run_refine_test_cases_and_code": (SDLC.refine_test_cases_and_code, "collect_test_cases_human_feedback"), "run_save_testing_outputs": (SDLC.save_testing_outputs, "run_generate_initial_quality_analysis"), "run_generate_initial_quality_analysis": (SDLC.generate_initial_quality_analysis, "run_generate_quality_feedback"), "run_generate_quality_feedback": (SDLC.generate_quality_feedback, "collect_quality_human_feedback"), "run_refine_quality_and_code": (SDLC.refine_quality_and_code, "collect_quality_decision"), "run_generate_initial_deployment": (lambda state: SDLC.generate_initial_deployment(state, st.session_state.current_prefs), "run_generate_deployment_feedback"), "run_generate_deployment_feedback": (SDLC.generate_deployment_feedback, "collect_deployment_human_feedback"), "run_refine_deployment": (SDLC.refine_deployment, "collect_deployment_decision"), }
+
+# --- Main Execution Logic ---
+if st.session_state.get('config_applied', False):
+    current_stage = st.session_state.stage
+    if current_stage.startswith("run_"):
+        if current_stage in workflow_map: func, next_stage = workflow_map[current_stage]; run_workflow_step(func, next_stage)
+        else: st.error(f"Unknown processing stage '{current_stage}'. Resetting."); logger.critical(f"Halted at unknown stage: {current_stage}."); initialize_state(); st.rerun()
+# --- END OF app.py ---

requirements.txt

@@ -0,0 +1,13 @@
+langgraph 
+langchain 
+langchain-openai 
+langchain-groq 
+langgraph-supervisor 
+langmem 
+pytest 
+bandit
+typing_extensions
+streamlit
+open-deep-research
+tavily-python
+plantuml