Enhance requirement and user story generation prompts for clarity; implement feedback processing and download link for artifacts in Streamlit UI.

src/langgraphagenticai/nodes/sdlc_node.py

@@ -42,7 +42,14 @@ class SdlcNode:
                 "project_scope": state.project_scope if state.project_scope is not None else "No project scope provided",
                 "project_objectives": state.project_objectives if state.project_objectives is not None else "No project objectives provided",
             }
-            prompt_string = f"Generate detailed requirements for the following project details:\n{json.dumps(requirements_input, indent=2)}"
+            prompt_string = f"""Based on the following project details, generate a comprehensive list of detailed software requirements.
+                                Ensure the requirements are clear, unambiguous, verifiable, and complete based on the provided description, goals, scope, and objectives.
+
+                                Project Details:
+                                {json.dumps(requirements_input, indent=2)}
+
+                                Detailed Requirements:
+                            """""
             # Construct a list of messages for the LLM
             messages = [SystemMessage(content="You are an expert project requirements generator."),HumanMessage(content=prompt_string)]
             state.generated_requirements = self.llm(messages)
@@ -60,7 +67,15 @@ class SdlcNode:
 
         try:
             if state.generated_requirements:
-                prompt_string = f"Generate user stories based on the following requirements:\n{state.generated_requirements}"
+                prompt_string =  f"""Based on the following software requirements, generate a list of user stories.
+                                Each user story should follow the format: 'As a [type of user], I want [some goal] so that [some reason/benefit].'
+                                Ensure the user stories cover the key functionalities outlined in the requirements and are actionable from a development perspective.
+
+                                Requirements:
+                                {state.generated_requirements}
+
+                                User Stories:
+                                """""
                 messages = [
                     SystemMessage(content="You are an expert at creating user stories for software development projects. Each user story should follow the format: 'As a [type of user], I want [some goal] so that [some reason/benefit].' Ensure the user stories are clear, concise, and cover the key functionalities outlined in the requirements."),
                     HumanMessage(content=prompt_string)
@@ -73,4 +88,77 @@ class SdlcNode:
         except Exception as e:
             logger.error(f"Error generating user stories: {e}")
             state.user_stories = f"Error generating user stories: {str(e)}"
-            return {"user_stories": state.user_stories}
+            return {"user_stories": state.user_stories}
+    
+    @log_entry_exit
+    def process_feedback(self, state: State) -> dict:
+        """Process user feedback received for the current stage's output."""
+        logger.info(f"Processing user feedback for stage: {state.current_stage.value}")
+
+        # Assume feedback is available in Streamlit's session state when this node is triggered
+        feedback_text = st.session_state.get("user_feedback")
+
+        if feedback_text and feedback_text.strip(): # Check if feedback exists and is not just whitespace
+            logger.info(f"Feedback received: {feedback_text}")
+            # Add feedback to the state associated with the current stage
+            # The feedback is typically about the *output* of the previous stage,
+            # but we associate it with the *current* stage where it's processed.
+            # Or, one could argue it belongs to the stage *just completed*.
+            # Let's associate it with the stage that produced the artifact being reviewed.
+            # If this node is called *after* generating user stories (part of PLANNING),
+            # then the feedback is about the planning artifacts.
+            stage_for_feedback = SDLCStages.PLANNING # Assuming feedback after user stories review is about planning
+            state.add_feedback(stage_for_feedback, feedback_text)
+            logger.info(f"Feedback added for stage: {stage_for_feedback.value}")
+
+            # Clear the feedback from session state after processing
+            if "user_feedback" in st.session_state:
+                del st.session_state["user_feedback"]
+                logger.info("Feedback cleared from session state.")
+
+            # You might want to store the raw feedback text temporarily or trigger a revision process
+            # state.raw_feedback = feedback_text # Example of storing raw feedback if needed
+
+            return {"feedback_processed": True, "status": "feedback_added"}
+        else:
+            logger.info("No new user feedback found in session state.")
+            return {"feedback_processed": False, "status": "no_feedback"}
+
+    # Add more nodes for Design, Development, Testing, Deployment etc. following a similar pattern
+    # Each node would take the state, perform an action (potentially using LLM),
+    # update the state with the generated artifact, and return a dict indicating the result.
+
+    # Example placeholder for a Planning Review node (determines next step after planning)
+    @log_entry_exit
+    def planning_review(self, state: State) -> str:
+        """Determines the next step after the planning stage."""
+        logger.info("Executing planning_review.")
+
+        # Check if feedback was provided in the previous step
+        feedback_given = st.session_state.get("feedback_submitted", False) # Assuming a flag is set in Streamlit
+
+        if feedback_given:
+             # Clear the feedback flag
+             if "feedback_submitted" in st.session_state:
+                 del st.session_state["feedback_submitted"]
+             # If feedback was given, we might want to revise planning or user stories
+             # This decision logic would go here. For simplicity, let's assume
+             # feedback means we go back to regeneration or processing the feedback more deeply.
+             # A more complex graph might have a dedicated feedback processing node.
+             logger.info("Feedback detected, potentially returning for revision or processing.")
+             # Return node names or conditional edges based on feedback content or presence
+             # Example: return "process_feedback_node" or "generate_requirements"
+             return "process_feedback" # Assuming the process_feedback node handles the revision logic
+
+        # If no feedback, proceed to the next stage
+        next_stage_enum = state.get_next_stage() # Get the next enum stage (e.g., SDLCStages.DESIGN)
+
+        if next_stage_enum and next_stage_enum != SDLCStages.COMPLETE:
+            next_stage_name = next_stage_enum.value # Get the string name (e.g., "design")
+            logger.info(f"No feedback detected. Proceeding to the next stage: {next_stage_name}")
+            # In LangGraph, return the name of the node to transition to
+            # Assuming you have nodes named "design", "development", etc.
+            return next_stage_name
+        else:
+            logger.info("Planning complete, no further stages defined or project is complete.")
+            return "end" # Indicate completion of the workflow or section

src/langgraphagenticai/ui/streamlitui/display_result_sdlc.py

@@ -95,14 +95,12 @@ class DisplaySdlcResult:
             with st.expander("Generated Requirements"):
                 st.subheader("Generated Requirements")
                 st.markdown(st.session_state["generated_requirements"].content)
-                self._create_download_link(st.session_state["generated_requirements"].content, "requirements.txt", "Download Requirements")
                 if st.button("Save Requirements", key="save_requirements_planning"):  # Unique key
                     self._save_artifact(st.session_state["generated_requirements"].content, "requirements.txt")
         if st.session_state.get("user_stories_generated"):
             with st.expander("Generated User Stories"):
                 st.subheader("Generated User Stories")
                 st.markdown(st.session_state["generated_user_stories"].content)
-                self._create_download_link(st.session_state["generated_user_stories"].content, "user_stories.txt", "Download User Stories")
                 if st.button("Save User Stories", key="save_user_stories_planning"):  # Unique key
                     self._save_artifact(st.session_state["generated_user_stories"].content, "user_stories.txt")
         if not st.session_state.get("requirements_generated") and not st.session_state.get("user_stories_generated"):
@@ -264,43 +262,14 @@ class DisplaySdlcResult:
         st.session_state["requirements_generated"] = requirements is not None
         st.session_state["user_stories_generated"] = user_stories is not None
 
-    def _create_download_link(self, data, filename, label):
-        """Creates a download link for the given data."""
-        b64 = base64.b64encode(data.encode()).decode()
-        href = f'<a href="data:file/txt;base64,{b64}" download="{filename}">{label}</a>'
-        st.markdown(href, unsafe_allow_html=True)
 
     def _save_artifact(self, data, filename):
-        """Saves the artifact data to a file in a user-specified directory."""
+        """Saves the artifact data to a file, prompting the user for the download."""
         try:
-            # Get the current working directory as default
-            default_dir = os.getcwd()
-            
-            # Ask user for directory path
-            dir_path = st.text_input(
-                "Enter directory path to save the file:", 
-                value=default_dir,
-                help="Specify the directory where you want to save the file"
-            )
-            
-            # Create a button to save the file
-            if st.button("Save File"):
-                # Check if directory exists
-                if not os.path.exists(dir_path):
-                    st.warning(f"Directory does not exist: {dir_path}")
-                    create_dir = st.button("Create directory?")
-                    if create_dir:
-                        os.makedirs(dir_path)
-                    else:
-                        return
-                
-                # Create full filepath
-                filepath = os.path.join(dir_path, filename)
-                
-                # Save the file
-                with open(filepath, "w") as f:
-                    f.write(data)
-                
-                st.success(f"Artifact saved to {filepath}")
+            # Create a download link using streamlit
+            b64 = base64.b64encode(data.encode()).decode()
+            st.markdown(f'<a href="data:file/txt;base64,{b64}" download="{filename}">Download {filename}</a>', unsafe_allow_html=True)
+            st.success(f"Artifact download link created. Click to download {filename}")
+
         except Exception as e:
-            st.error(f"Error saving artifact: {e}")
+            st.error(f"Error creating download link: {e}")