check streamlit app

src/langgraphagenticai/graph/graph_builder_sdlc.py

@@ -41,7 +41,7 @@ class SdlcGraphBuilder:
             # Conditional edge after feedback processing
             graph_builder.add_conditional_edges(
                 "ProcessFeedback",
-                sldc_node.feedbackRoute,
+                sldc_node.feedback_route,
                 {
                     "accept": END,
                     "reject": "GenerateUserStories"

src/langgraphagenticai/nodes/sdlc_node.py

@@ -137,65 +137,76 @@ class SdlcNode:
     
     @log_entry_exit
     def process_feedback(self, state: State) -> dict:
-        """Process user feedback by adding it to the state."""
-        current_stage_value = state.current_stage.value if isinstance(state.current_stage, SDLCStages) else state.current_stage
-        logger.debug(f"Processing feedback for stage: {current_stage_value}")
-
-        raw_feedback = state.feedback
-        logger.debug(f"Raw feedback data: {raw_feedback}")
-
-        # Only accept if feedback is {current_stage: ["accept"]}
-        if (
-            isinstance(raw_feedback, dict)
-            and current_stage_value in raw_feedback
-            and isinstance(raw_feedback[current_stage_value], list)
-            and raw_feedback[current_stage_value]
-            and raw_feedback[current_stage_value][-1].strip().lower() == "accept"
-        ):
-            state.feedback_decision = "accept"
-            return {
-                "feedback_decision": "accept",
-                "feedback": state.feedback
+            """
+            Process user feedback passed via state and update state with decision.
+            Only { "current_stage": ["accept"] } ends the process.
+            """
+            logger.debug(f"--- Entering process_feedback ---")
+            logger.debug(f"Input state: {state.to_dict() if isinstance(state, State) else state}")
+
+            # Normalize current_stage to enum
+            if isinstance(state.current_stage, str):
+                try:
+                    current_stage_enum = SDLCStages(state.current_stage)
+                except ValueError:
+                    logger.warning(f"Unknown current_stage string: {state.current_stage}")
+                    current_stage_enum = None
+            else:
+                current_stage_enum = state.current_stage
+
+            current_stage_value = current_stage_enum.value if current_stage_enum else state.current_stage
+
+            logger.debug(f"Processing feedback for stage: {current_stage_value}")
+
+            raw_feedback = state.feedback
+            logger.debug(f"Raw feedback data received in state: {raw_feedback}")
+
+            # Only accept if feedback is {current_stage: ["accept"]}
+            logger.debug(f"Checking acceptance: current_stage_value={current_stage_value}, raw_feedback={raw_feedback}")
+            if (
+                isinstance(raw_feedback, dict)
+                and current_stage_value in raw_feedback
+                and isinstance(raw_feedback[current_stage_value], list)
+                and raw_feedback[current_stage_value] # Check if list is not empty
+                and raw_feedback[current_stage_value][-1].strip().lower() == "accept"
+            ):
+                logger.info(f"Feedback for stage '{current_stage_value}' is ACCEPT. Ending flow.")
+                state.feedback_decision = "accept"
+            else:
+                logger.info(f"Feedback for stage '{current_stage_value}' is not accept. Looping back.")
+                state.feedback_decision = "reject"
+
+            return_value = {
+                "feedback_decision": state.feedback_decision,
+                "feedback": state.feedback # Pass the original feedback dict back
             }
-        else:
-            state.feedback_decision = "reject"
-            return {
-                "feedback_decision": "reject",
-                "feedback": state.feedback
-            }
-
+            logger.debug(f"Returning from process_feedback: {return_value}")
+            logger.debug(f"--- Exiting process_feedback ---")
+            return return_value
     @log_entry_exit
-    def feedbackRoute(self, state: State) -> str:
-        """Route feedback based on SDLCState feedback format (Dict[str, List[str]]).
-        Accept if feedback for current stage is empty or not present, reject if there are comments.
-        """
-        logger.debug(f"Routing feedback with state type: {type(state)}")
-        logger.debug(f"State content: {state}")
+    def feedback_route(self, state: State) -> str:
+        """Routes based on the feedback decision stored in the state."""
+        logger.debug(f"--- Entering feedback_route ---")
+        logger.debug(f"Routing feedback. Current state includes feedback_decision: {hasattr(state, 'feedback_decision')}")
         
-        feedback_decision = None
-        
-        # If state is a dict with feedback_decision
-        if isinstance(state, dict) and "feedback_decision" in state:
-            feedback_decision = state["feedback_decision"]
-            logger.debug(f"Found feedback_decision in state dict: {feedback_decision}")
-        # If state is a SDLCState object
-        elif isinstance(state, state.SDLCState):
-            logger.debug(f"State is SDLCState object")
-            if hasattr(state, "feedback_decision"):
-                feedback_decision = state.feedback_decision
-                logger.debug(f"Found feedback_decision as attribute: {feedback_decision}")
-        # Try to get from node output
+        logger.debug(f"Full state content received by feedback_route: {state.to_dict() if isinstance(state, SDLCState) else state}")
+
+        if not isinstance(state, State):
+            logger.error(f"Incorrect state type passed to feedback_route: {type(state)}. Defaulting to reject.")
+            logger.debug(f"--- Exiting feedback_route (routing: reject due to type error) ---")
+            
+            return "reject"
+
+    
+        feedback_decision = state.feedback_decision
+        logger.debug(f"Feedback decision read from state object: {feedback_decision}")
+
+        if feedback_decision == "accept":
+            logger.info("Feedback accepted. Routing to END.")
+            logger.debug(f"--- Exiting feedback_route (routing: accept) ---")
+            return "accept"
         else:
-            logger.debug(f"State is neither dict nor SDLCState, trying alternative methods")
-            try:
-                if hasattr(state, "get"):
-                    node_output = state.get("ProcessFeedback", {})
-                    logger.debug(f"ProcessFeedback node output: {node_output}")
-                    feedback_decision = node_output.get("feedback_decision")
-                    logger.debug(f"Found feedback_decision in node output: {feedback_decision}")
-            except Exception as e:
-                logger.error(f"Error extracting feedback_decision: {e}")
-        
-        route = "accept" if feedback_decision == "accept" else "reject"
-        logger.debug(f"Final routing decision: {route}")
-        return route
+            
+            logger.info(f"Feedback decision is '{feedback_decision}'. Routing back for revision.")
+            logger.debug(f"--- Exiting feedback_route (routing: reject) ---")
+            return "reject"

src/langgraphagenticai/state/state.py

@@ -82,38 +82,7 @@ class SDLCState(BaseModel):
         Level of Detail: Specific, quantifiable, and time-bound.
         Example Project: Developing a Mobile Application for a Local Bookstore
 
-Project Description: Develop a user-friendly mobile application for "The Book Nook," a local bookstore in Bangalore, to allow customers to browse their inventory, place orders online, and learn about upcoming events.
-
-Project Goals:
-
-        Increase sales and revenue for The Book Nook.
-        Enhance customer engagement and loyalty.
-        Modernize The Book Nook's presence and reach a wider audience in Bangalore.
-Project Scope:
-
-Inclusions:
-    Developing a mobile application compatible with Android and iOS.
-    Features: Browsing book catalog with search and filtering, viewing book details (description, author, price, availability), creating user accounts, adding books to a shopping cart, secure online payment integration, order history, push notifications for new arrivals and events, information about store hours and location.
-    Integration with the bookstore's existing inventory management system.
-    Basic user support documentation.
-Exclusions:
-    Developing a separate tablet application.
-    Implementing a loyalty points program (will be considered in a future phase).
-    Integrating with social media platforms for direct purchasing.
-    Providing real-time inventory updates beyond a daily sync.
-    Developing advanced analytics dashboards for the bookstore owner in this phase.
-Project Objectives (SMART):
-
-    Increase online sales by 15% within the first six months of the app launch (Measurable, Achievable, Relevant, Time-bound).
-    Achieve an average user rating of 4.5 stars or higher on both app stores within three months of launch (Measurable, Achievable, Relevant, Time-bound).
-    Acquire 500 new registered app users within the first month of launch (Measurable, Achievable, Relevant, Time-bound).
-    Successfully integrate the app with the existing inventory system with no data loss by the end of the development phase (Measurable, Achievable, Relevant, Time-bound).
-    In Summary:
-
-The description gives a general idea of the project.
-The goals state the desired high-level outcomes.
-The scope defines the boundaries of the work to be done.
-The objectives provide specific, measurable steps to achieve the goals within the defined scope.   
+ 
 """
 
     # core state attributes 
@@ -140,6 +109,7 @@ The objectives provide specific, measurable steps to achieve the goals within th
 
     # Feedback
     feedback: Dict[str, List[str]] = Field(default_factory=dict, description="User feedback by stage")
+    feedback_decision: Optional[str] = Field(None, description="Decision after processing feedback (accept/reject)")
 
     # Metadata
     created_at: str = Field(default_factory=lambda: datetime.now().isoformat(), description="Creation timestamp")
@@ -167,6 +137,7 @@ The objectives provide specific, measurable steps to achieve the goals within th
         # Update stage
         self.current_stage = new_stage
         self.last_updated = datetime.now().isoformat()
+        
     def add_feedback(self, stage: SDLCStages, feedback_text: str):
         """
         Add feedback for a specific stage.

src/langgraphagenticai/ui/streamlitui/display_result_sdlc.py

@@ -9,13 +9,13 @@ import functools
 import time
 import base64
 from src.langgraphagenticai.logging.logging_utils import logger, log_entry_exit
-import os  # Import the os module
-from langgraph.graph import END # Import END for checking graph completion
+import os
+from langgraph.graph import END
 
 # --- Pydantic Model for Feedback ---
 class ReviewFeedback(BaseModel):
     approved: bool = Field(description="Approval status: True for approved, False for rejected")
-    comments: str = Field(description="Reviewer comments", default="") # Default to empty string
+    comments: str = Field(description="Reviewer comments", default="")
 
 # --- Main Display Class ---
 class DisplaySdlcResult:
@@ -27,20 +27,21 @@ class DisplaySdlcResult:
     def _initialize_session_state(self):
         """Initialize session state variables if they don't exist."""
         defaults = {
-            "sdlc_stage": "planning", # Tracks the conceptual stage
+            "sdlc_stage": "planning",
             "project_name": "",
             "project_description": "",
             "project_goals": "",
             "project_scope": "",
             "project_objectives": "",
-            "requirements_generated": False, # UI flag: Have requirements been generated at least once?
-            "user_stories_generated": False, # UI flag: Have user stories been generated and are ready for review/approved?
-            "generated_requirements": None, # Stores the actual artifact text
-            "generated_user_stories": None, # Stores the actual artifact text
-            "feedback": None, # Stores feedback dict for process_feedback node (transient)
-            "needs_resume_after_feedback": False, # Flag to trigger graph resume
-            "graph_completed": False, # Flag to indicate workflow completion (reached END)
-            "graph_running": False, # Flag to prevent concurrent runs/UI updates during stream
+            "requirements_generated": False,
+            "user_stories_generated": False,
+            "generated_requirements": None,
+            "generated_user_stories": None,
+            "feedback": None,
+            "needs_resume_after_feedback": False,
+            "graph_completed": False,
+            "graph_running": False,
+            "feedback_pending": False,
         }
         for key, value in defaults.items():
             if key not in st.session_state:
@@ -51,60 +52,55 @@ class DisplaySdlcResult:
         """Manages the overall SDLC workflow display and interaction in Streamlit."""
         st.title("Software Development Life Cycle (SDLC) Workflow")
 
+        # Prevent concurrent runs
+        if st.session_state.get("graph_running"):
+            st.warning("Workflow is already running. Please wait.")
+            logger.warning("Workflow blocked due to graph_running=True")
+            return
+
+        # Handle resumption
+        if st.session_state.get("needs_resume_after_feedback"):
+            logger.info("Detected need to resume graph after feedback.")
+            st.session_state["graph_running"] = True
+            self._resume_sdlc_graph()
+            st.session_state["graph_running"] = False
+            return  # Avoid further processing to prevent UI conflicts
+
+        # Display UI
         phases = ["Planning", "Design", "Development", "Testing", "Deployment"]
         icons = ["🗓️", "📐", "💻", "🧪", "🚀"]
         tabs = st.tabs([f"{icon} {phase}" for icon, phase in zip(icons, phases)])
 
-        # --- Check if we need to resume the graph ---
-        needs_resume = st.session_state.get("needs_resume_after_feedback", False)
-        if needs_resume and not st.session_state.get("graph_running", False):
-            logger.info("Detected need to resume graph after feedback.")
-            st.session_state["needs_resume_after_feedback"] = False # Reset the flag immediately
-            st.session_state["graph_running"] = True # Set lock
-            self._resume_sdlc_graph() # Call the function to handle resumption
-            st.session_state["graph_running"] = False # Release lock
-            # Rerun to update the UI based on the resumed graph's state changes
-            st.rerun()
-            return # Stop further processing in this run
-
-        # --- Display content based on the current state ---
-        with tabs[0]:  # Planning Tab
-            # Only show collection form if requirements haven't been generated yet
+        with tabs[0]:
             if not st.session_state.get("requirements_generated"):
-                 self._display_planning_phase() # Contains _collect_project_requirements
-            # Always display artifacts and feedback form if artifacts exist
-            # The feedback form is only active if stories are generated
+                self._display_planning_phase()
             self._display_planning_artifacts()
 
-        # --- Placeholder Tabs ---
         with tabs[1]: self._display_design_phase(); self._display_design_artifacts()
         with tabs[2]: self._display_development_phase(); self._display_development_artifacts()
         with tabs[3]: self._display_testing_phase(); self._display_testing_artifacts()
         with tabs[4]: self._display_deployment_phase(); self._display_deployment_artifacts()
 
-        # --- Display Completion Status ---
         if st.session_state.get("graph_completed"):
             st.success("✅ SDLC Planning Phase Completed Successfully!")
+            st.markdown("You can restart the workflow or review the artifacts.")
 
-        # --- Restart Button ---
         st.markdown("---")
         if st.button("Restart SDLC Workflow", key="restart_button"):
+            logger.info("Restart SDLC Workflow button clicked")
             self._reset_session_state()
             st.rerun()
 
     @log_entry_exit
     def _reset_session_state(self):
         """Resets relevant session state keys to start the workflow over."""
-        keys_to_reset = list(st.session_state.keys()) # Get all keys
+        keys_to_reset = list(st.session_state.keys())
         logger.info("Resetting session state.")
         for key in keys_to_reset:
-            # Avoid deleting internal Streamlit keys or keys we might want to persist
-            if not key.startswith("_"): # Basic check, adjust if needed
-                 del st.session_state[key]
-        # Re-initialize after clearing
+            if not key.startswith("_"):
+                del st.session_state[key]
         self._initialize_session_state()
 
-
     @log_entry_exit
     def _display_planning_phase(self):
         """Displays the requirement collection section."""
@@ -116,13 +112,12 @@ class DisplaySdlcResult:
         """Displays generated planning artifacts and the feedback form."""
         st.subheader("Planning Artifacts")
         requirements_exist = st.session_state.get("requirements_generated")
-        stories_exist = st.session_state.get("user_stories_generated")  # This flag indicates readiness for review/approval
+        stories_exist = st.session_state.get("user_stories_generated")
 
-        # Ensure feedback is initialized as a dictionary
         if "feedback" not in st.session_state or st.session_state["feedback"] is None:
             st.session_state["feedback"] = {}
+            logger.info("Initialized empty feedback dictionary in session state.")
 
-        # Display Requirements if they exist
         if requirements_exist:
             with st.expander("Generated Requirements", expanded=True):
                 st.markdown(st.session_state["generated_requirements"])
@@ -131,14 +126,12 @@ class DisplaySdlcResult:
         else:
             st.info("Requirements will be displayed here after generation.")
 
-        # Display User Stories and Feedback Form ONLY if stories are generated and ready for review
         if stories_exist:
             with st.expander("Generated User Stories", expanded=True):
                 st.markdown(st.session_state["generated_user_stories"])
                 if st.button("Save User Stories", key="save_user_stories_planning"):
                     self._save_artifact(st.session_state["generated_user_stories"], "user_stories.txt")
 
-            # --- Feedback Section ---
             if not st.session_state.get("graph_completed"):
                 st.markdown("### Feedback on User Stories")
                 decision_options = ("Approve", "Reject")
@@ -147,56 +140,126 @@ class DisplaySdlcResult:
                     decision_options,
                     key="user_story_feedback_decision",
                     horizontal=True,
-                    index=0  # Default to Approve
+                    index=0
                 )
-
                 comments = st.text_area(
                     "Comments (Required for Rejection):",
-                    # value="Include Subscriptions model to retain customer",  # Example default
                     placeholder="Include Subscriptions model to retain customer",
                     key="user_story_feedback_comments"
                 )
-
-                if st.button("Submit Review", key="submit_review_button"):
+                submit_disabled = st.session_state.get("feedback_pending", False) or st.session_state.get("graph_running", False)
+                if st.button("Submit Review", key="submit_review_button", disabled=submit_disabled):
+                    if st.session_state.get("feedback_pending"):
+                        st.warning("Feedback is already being processed. Please wait.")
+                        return
+                    st.session_state["feedback_pending"] = True
                     if selected_decision == "Reject" and not comments.strip():
                         st.error("Comments are required when rejecting.")
+                        st.session_state["feedback_pending"] = False
                     else:
                         is_approved = (selected_decision == "Approve")
                         logger.info(f"Feedback submitted: {'Approved' if is_approved else 'Rejected with comments.'}")
-
-                        # Structure feedback to match SDLCState format
-                        current_stage = "planning"  # Assuming feedback is always on Planning in this example
-                        new_feedback = {
-                            current_stage: [comments] if not is_approved else []  # Only store comments if rejected
+                        current_stage = "planning"
+                        st.session_state["feedback"] = {
+                            current_stage: ["accept"] if is_approved else [comments.strip()]
                         }
-
-                        # Update session state with the new feedback structure
-                        if current_stage not in st.session_state["feedback"]:
-                            st.session_state["feedback"][current_stage] = ["accept"]
-
-                        if not is_approved:
-                            st.session_state["feedback"][current_stage].append(comments)
-
-                        logger.info("Session state updated with feedback: %s", st.session_state["feedback"])
-
-                        # --- Signal that the graph needs to resume ---
+                        logger.info("Feedback stored: %s", st.session_state["feedback"])
                         st.session_state["needs_resume_after_feedback"] = True
-
-                        # If rejected, immediately hide the stories from the UI until regenerated
                         if not is_approved:
                             st.session_state["user_stories_generated"] = False
-
-                        logger.info("Feedback stored. Triggering rerun for graph resumption.")
+                        st.session_state["feedback_pending"] = False
                         st.rerun()
             else:
-                st.success("User stories approved.")  # Show if graph is completed
+                st.success("✅ User stories approved. Planning phase completed.")
+                st.markdown("The feedback form is disabled as the workflow is complete.")
         elif requirements_exist and not stories_exist:
             st.info("User stories will be displayed here after generation or if awaiting regeneration after feedback.")
         elif not requirements_exist and not stories_exist:
             st.info("No artifacts generated yet in the Planning phase.")
 
+    @log_entry_exit
+    def _resume_sdlc_graph(self):
+        """Resumes the graph execution from the checkpoint after feedback."""
+        logger.info("Resuming SDLC graph execution...")
+        logger.info("Session state before resumption: %s", st.session_state)
+        feedback_data = st.session_state.get("feedback")
+        logger.info(f"Feedback data: %s", feedback_data)
+        
+        # Prepare input data with project details and feedback
+        resume_input_data = {
+            "feedback": feedback_data,
+            "project_name": st.session_state.get("project_name"),
+            "project_description": st.session_state.get("project_description"),
+            "project_goals": st.session_state.get("project_goals"),
+            "project_scope": st.session_state.get("project_scope"),
+            "project_objectives": st.session_state.get("project_objectives"),
+            "generated_requirements": st.session_state.get("generated_requirements"),
+            "generated_user_stories": st.session_state.get("generated_user_stories"),
+        }
+        
+        thread_id = self.config.get("configurable", {}).get("thread_id", "N/A")
+        checkpoint = None
+        if hasattr(self.graph, 'checkpointer'):
+            checkpoint_tuple = self.graph.checkpointer.get_tuple({"configurable": {"thread_id": thread_id}})
+            if checkpoint_tuple:
+                checkpoint = checkpoint_tuple.checkpoint
+                logger.info(f"Checkpoint retrieved: %s", checkpoint)
+            else:
+                logger.error("No checkpoint found for thread_id: %s", thread_id)
+                st.error("No valid checkpoint found. Please restart the workflow.")
+                return
+        else:
+            logger.error("Graph checkpointer not available.")
+            st.error("Graph configuration error. Please restart the workflow.")
+            return
+
+        requirements = st.session_state.get("generated_requirements")
+        user_stories = st.session_state.get("generated_user_stories")
+        graph_completed_flag = False
+
+        with st.spinner("Processing feedback and continuing workflow..."):
+            try:
+                # Stream from checkpoint with feedback and project details
+                for event in self.graph.stream(resume_input_data, config=self.config):
+                    logger.info(f"Resume Event: %s", json.dumps(event, default=str))
+                    for node, state in event.items():
+                        if state is None:
+                            logger.info(f"Node '{node}' has null state, skipping.")
+                            continue
+                        # Handle tuple or other non-dict states
+                        if not isinstance(state, dict):
+                            logger.warning(f"Node '{node}' state is not a dict: {type(state)}. Skipping state processing.")
+                            continue
+                        logger.info(f"Node '{node}' updated state: %s", state)
+                        if "generated_requirements" in state:
+                            requirements = state["generated_requirements"]
+                        if "user_stories" in state:
+                            user_stories = state["user_stories"]
+                        if "feedback_decision" in state:
+                            logger.info("Feedback decision: %s", state["feedback_decision"])
+                        # Check for END condition
+                        if node == END or node == "__end__" or state.get("next_node") == END:
+                            logger.info("Graph reached END node")
+                            graph_completed_flag = True
+                        # Handle interrupt for feedback
+                        if node == "__interrupt__":
+                            logger.info("Graph interrupted for feedback processing")
+            except Exception as e:
+                logger.error(f"Error during graph stream: %s", e, exc_info=True)
+                st.error(f"An error occurred during graph resumption: {e}")
+                return
+
+        # Update session state
+        st.session_state["generated_requirements"] = requirements
+        st.session_state["generated_user_stories"] = user_stories
+        st.session_state["requirements_generated"] = requirements is not None
+        st.session_state["user_stories_generated"] = user_stories is not None and not graph_completed_flag
+        st.session_state["graph_completed"] = graph_completed_flag
+        st.session_state["needs_resume_after_feedback"] = False
+        st.session_state["feedback"] = {}
+        logger.info("Graph resumption completed. Graph completed: %s", graph_completed_flag)
+        logger.info("Session state after resumption: %s", st.session_state)
 
-    # --- Placeholder Display Functions for Other Phases ---
     @log_entry_exit
     def _display_design_phase(self):
         st.header("Design Phase")
@@ -237,11 +300,9 @@ class DisplaySdlcResult:
         st.subheader("Deployment Artifacts")
         st.info("Deployment artifacts (e.g., deployment plans, monitoring dashboards) will be displayed here.")
 
-    # --- Requirement Collection Form ---
     @log_entry_exit
     def _collect_project_requirements(self):
         """Displays the form to collect initial project details."""
-        
         DefaultProjectName = "The Book Nook"
         DefaultDescription = """Develop a user-friendly mobile application for "The Book Nook," a local bookstore in Bangalore, 
                                 to allow customers to browse their inventory, place orders online, and learn about upcoming events."""
@@ -273,20 +334,18 @@ class DisplaySdlcResult:
             project_objectives = st.text_area("Project Objectives", value=st.session_state.get("project_objectives", DefaultObjectives), placeholder=DefaultObjectives, height=150)
 
             submit = st.form_submit_button("Generate Requirements & User Stories")
-            if submit and not st.session_state.get("graph_running", False):
-                # Update session state with form values
+            if submit and not st.session_state.get("graph_running"):
                 st.session_state["project_name"] = project_name.strip() or DefaultProjectName
                 st.session_state["project_description"] = project_description.strip() or DefaultDescription
                 st.session_state["project_goals"] = project_goals.strip() or DefaultGoals
                 st.session_state["project_scope"] = project_scope.strip() or DefaultScope
                 st.session_state["project_objectives"] = project_objectives.strip() or DefaultObjectives
-                st.session_state["sdlc_stage"] = "planning" # Ensure stage is set
-
+                st.session_state["sdlc_stage"] = "planning"
                 logger.info("Initial project details submitted. Running graph for the first time.")
-                st.session_state["graph_running"] = True # Set lock
-                self._run_sdlc_graph_initial() # Call the initial run function
-                st.session_state["graph_running"] = False # Release lock
-                st.rerun() # Rerun to display the generated artifacts
+                st.session_state["graph_running"] = True
+                self._run_sdlc_graph_initial()
+                st.session_state["graph_running"] = False
+                st.rerun()
 
     @log_entry_exit
     def _run_sdlc_graph_initial(self):
@@ -306,134 +365,31 @@ class DisplaySdlcResult:
             try:
                 for event in self.graph.stream(input_data, self.config):
                     logger.info(f"Initial Run Event: {event}")
-                    event_key = list(event.keys())[0] 
-
-                    
+                    event_key = list(event.keys())[0]
                     if event_key == "__interrupt__":
-                         logger.info("Graph interrupted as expected after generating artifacts.")
-                         last_node_state = event.get("__interrupt__") 
-                         if last_node_state:
-                             requirements = last_node_state.get("generated_requirements", requirements)
-                             user_stories = last_node_state.get("generated_user_stories", user_stories)
-                         break # Exit loop after interrupt is handled
-
-                    # Process node updates
+                        logger.info("Graph interrupted as expected after generating artifacts.")
+                        last_node_state = event.get("__interrupt__")
+                        if last_node_state:
+                            requirements = last_node_state.get("generated_requirements", requirements)
+                            user_stories = last_node_state.get("generated_user_stories", user_stories)
+                        break
                     for node, state in event.items():
                         if state is None: continue
                         logger.info(f"Node '{node}' updated state.")
-                        # Capture the latest generated artifacts from the state
                         if "generated_requirements" in state:
                             requirements = state["generated_requirements"]
                         if "user_stories" in state:
                             user_stories = state["user_stories"]
-
             except Exception as e:
-                 logger.error(f"Error during initial graph stream: {e}", exc_info=True)
-                 st.error(f"An error occurred during graph execution: {e}")
-                 return # Stop processing if stream fails
-
-       
-        st.session_state["generated_requirements"] = requirements
-        st.session_state["generated_user_stories"] = user_stories
-        st.session_state["requirements_generated"] = requirements is not None
-        st.session_state["user_stories_generated"] = user_stories is not None # Mark stories as generated and ready for review
-        logger.info("Initial graph run finished (interrupted). Artifacts stored in session state.")
-
-
-    
-    @log_entry_exit
-    def _resume_sdlc_graph(self):
-        """Resumes the graph execution from the checkpoint after feedback."""
-        logger.info("Resuming SDLC graph execution...")
-
-        # Read feedback from session state
-        feedback_data = st.session_state.get("feedback")
-        logger.info(f"Feedback data read from session state: {feedback_data}")
-
-        # # Clear feedback from session state BEFORE calling stream
-        # if "feedback" in st.session_state:
-        #     try:
-        #         del st.session_state["feedback"]
-        #         logger.info("Feedback cleared from session state before resuming graph.")
-        #     except KeyError:
-        #         logger.warning("Attempted to delete 'feedback' from session state, but it was already gone.")
-
-        # Prepare input data for the resume call
-        resume_input_data = {}
-        if feedback_data:
-            resume_input_data["feedback"] = feedback_data
-        else:
-            logger.warning("Resume triggered, but no feedback data found. Using empty input.")
-
-        # Log checkpoint state for debugging
-        thread_id = self.config.get("configurable", {}).get("thread_id", "N/A")
-        checkpoint = None
-        if hasattr(self.graph, 'checkpointer'):
-            try:
-                checkpoint_tuple = self.graph.checkpointer.get_tuple({"configurable": {"thread_id": thread_id}})
-                if checkpoint_tuple:
-                    checkpoint = checkpoint_tuple.checkpoint
-                    logger.info(f"Checkpoint retrieved: {checkpoint}")
-                    next_node = checkpoint.get("next_node", "Unknown")
-                    logger.info(f"Next node from checkpoint: {next_node}")
-                else:
-                    logger.warning("No checkpoint found for thread_id: %s", thread_id)
-            except Exception as e:
-                logger.error(f"Failed to retrieve checkpoint: {e}", exc_info=True)
-
-        requirements = st.session_state.get("generated_requirements")
-        user_stories = st.session_state.get("generated_user_stories")
-        graph_completed_flag = False
-
-        with st.spinner("Processing feedback and continuing workflow..."):
-            try:
-                # Prefer resume if available
-                if hasattr(self.graph, "resume") and checkpoint:
-                    logger.info("Resuming graph from checkpoint using .resume()")
-                    for event in self.graph.resume(checkpoint, resume_input_data, self.config):
-                        logger.info(f"Resume Event: {event}")
-                        # Process node updates
-                        for node, state in event.items():
-                            if state is None: continue
-                            logger.info(f"Node '{node}' updated state during resume.")
-                            if "generated_requirements" in state:
-                                requirements = state["generated_requirements"]
-                            if "user_stories" in state:
-                                user_stories = state["user_stories"]
-                            if node == END or node == "END":
-                                graph_completed_flag = True
-                else:
-                    # Fallback to stream
-                    for event in self.graph.stream(resume_input_data, self.config):
-                        logger.info(f"Resume Event: {event}")
-                        # Process node updates
-                        for node, state in event.items():
-                            if state is None: continue
-                            logger.info(f"Node '{node}' updated state during resume.")
-                            if "generated_requirements" in state:
-                                requirements = state["generated_requirements"]
-                            if "user_stories" in state:
-                                user_stories = state["user_stories"]
-                            if node == END or node == "END":
-                                graph_completed_flag = True
-            except Exception as e:
-                logger.error(f"Error during graph resume stream: {e}", exc_info=True)
-                st.error(f"An error occurred during graph resumption: {e}")
+                logger.error(f"Error during initial graph stream: {e}", exc_info=True)
+                st.error(f"An error occurred during graph execution: {e}")
                 return
 
-        # Update session state after resume processing
         st.session_state["generated_requirements"] = requirements
         st.session_state["generated_user_stories"] = user_stories
         st.session_state["requirements_generated"] = requirements is not None
         st.session_state["user_stories_generated"] = user_stories is not None
-        st.session_state["graph_completed"] = graph_completed_flag
-
-        logger.info("Graph resumption processing finished.")
-
-
-
-
-
+        logger.info("Initial graph run finished (interrupted). Artifacts stored in session state.")
 
     @log_entry_exit
     def _save_artifact(self, content: str, filename: str):
@@ -445,5 +401,4 @@ class DisplaySdlcResult:
             logger.info(f"Generated download link for {filename}")
         except Exception as e:
             logger.error(f"Error creating download link for {filename}: {e}")
-            st.error(f"Could not generate download link for {filename}.")
-
+            st.error(f"Could not generate download link for {filename}.")