Updated latest code changes

.streamlit/config.toml

@@ -0,0 +1,6 @@
+[theme]
+base = "dark"
+primaryColor = "#1DB954"
+backgroundColor = "#000000"
+secondaryBackgroundColor = "#1a1a1a"
+textColor = "#ffffff"

app.py

@@ -0,0 +1,5 @@
+from src.sdlc.main import load_sdlc_app
+
+
+if __name__=="__main__":
+    load_sdlc_app()

requirements.txt

@@ -0,0 +1,8 @@
+langchain
+python-dotenv
+langchain-groq
+langchain-openai
+langchain-core
+langchain-community
+langgraph
+streamlit

src/sdlc/LLMS/groqllm.py

@@ -0,0 +1,22 @@
+import os
+import streamlit as st
+from langchain_groq import ChatGroq
+
+
+class GroqLLM:
+    def __init__(self,user_controls_input):
+        self.user_controls_input=user_controls_input
+
+    def get_llm_model(self):
+        try:
+            groq_api_key=self.user_controls_input['GROQ_API_KEY']
+            selected_groq_model=self.user_controls_input['selected_groq_model']
+            if groq_api_key=='' and os.environ["GROQ_API_KEY"] =='':
+                st.error("Please Enter the Groq API KEY")
+
+            llm = ChatGroq(api_key =groq_api_key, model=selected_groq_model, tools=[])
+
+        except Exception as e:
+            raise ValueError(f"Error Occurred with Exception : {e}")
+        return llm
+    

src/sdlc/LLMS/openaillm.py

@@ -0,0 +1,22 @@
+import os
+import streamlit as st
+from langchain_openai import ChatOpenAI
+
+
+class OpenAILLM:
+    def __init__(self,user_controls_input):
+        self.user_controls_input=user_controls_input
+
+    def get_llm_model(self):
+        try:
+            openai_api_key=self.user_controls_input['OPENAI_API_KEY']
+            selected_openai_model=self.user_controls_input['selected_openai_model']
+            if openai_api_key=='' and os.environ["OPENAI_API_KEY"] =='':
+                st.error("Please Enter the OPENAI API KEY")
+
+            llm = ChatOpenAI(api_key =openai_api_key, model=selected_openai_model)
+
+        except Exception as e:
+            raise ValueError(f"Error Occurred with Exception : {e}")
+        return llm
+    

src/sdlc/__init__.py

@@ -0,0 +1,27 @@
+import os
+import sys
+import logging
+from datetime import datetime
+
+logging_str = "[%(asctime)s: %(levelname)s: %(module)s: %(message)s]"
+log_dir = "logs"
+# Format: YYYY-MM-DD_HH-MM-SS
+timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+log_filename = f"{timestamp}_sdlc.log"
+
+log_filepath = os.path.join(log_dir, log_filename)
+os.makedirs(log_dir, exist_ok=True)
+
+
+
+logging.basicConfig(
+    level= logging.INFO,
+    format= logging_str,
+
+    handlers=[
+        logging.FileHandler(log_filepath),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+logger = logging.getLogger("sdlcLogger")

src/sdlc/graph/graph_builder.py

@@ -0,0 +1,122 @@
+from langgraph.graph import StateGraph, START,END
+from langgraph.checkpoint.memory import MemorySaver
+from src.sdlc.states.states import State
+from src.sdlc.nodes.userstories_node import UserStoriesNode
+from src.sdlc.nodes.userstories_feedback import UserStoriesFeedback
+from src.sdlc.nodes.design_documents_node import DesignDocumentsNode
+from src.sdlc.nodes.design_documents_feedback import DesignDocumentsFeedback
+from src.sdlc.nodes.design_summarize import DesignSummarizeNode
+from src.sdlc.nodes.code_subgraph_node import CoderSubgraphNode
+from src.sdlc.nodes.code_feedback import CodeFeedback
+from src.sdlc.nodes.security_check_node import SecurityCheckNode
+from src.sdlc.nodes.security_feedback import SecurityReviewFeedback
+from src.sdlc.nodes.test_cases_node import TestCasesNode
+from src.sdlc.nodes.test_cases_feedback import TestCasesFeedback
+from src.sdlc.nodes.qatesting_node import QATestingNode
+from src.sdlc.nodes.qa_feedback import QAFeedback
+from src.sdlc.nodes.deployment_node import DeploymentNode
+from src.sdlc.nodes.monitoring_node import MonitoringNode
+from src.sdlc.nodes.monitor_fb_node import MonitorFeedback
+from src.sdlc.nodes.maintanence_node import MaintanenceNode
+from src.sdlc.nodes.consolidated_node import ConsolidatedNode
+
+class GraphBuilder:
+
+    def __init__(self,model):
+        self.llm=model
+        self.memory=MemorySaver()
+        self.graph_builder=StateGraph(State)
+
+    def build_graph(self):
+        """
+        Builds a SDLC graph using LangGraph.
+        This method initializes nodes using the and integrates 
+        it into the graph. 
+        """
+        self.userstories_node=UserStoriesNode(self.llm)
+        self.human_fb_userstories=UserStoriesFeedback()
+        self.design_documents_node=DesignDocumentsNode(self.llm)
+        self.human_fb_design=DesignDocumentsFeedback()
+        self.design_summarizer=DesignSummarizeNode(self.llm)
+        self.coder_subgraph=CoderSubgraphNode(self.llm)
+        self.human_fb_code=CodeFeedback()
+        self.security_check_node=SecurityCheckNode(self.llm)
+        self.human_fb_review=SecurityReviewFeedback()
+        self.test_cases_node=TestCasesNode(self.llm)
+        self.human_fb_testcases=TestCasesFeedback()
+        self.qa_testing_node=QATestingNode()
+        self.human_fb_qatesting=QAFeedback()
+        self.deployment_node=DeploymentNode(self.llm)
+        self.monitoring_node=MonitoringNode(self.llm)
+        self.monitor_fb_node=MonitorFeedback()
+        self.maintanence_node=MaintanenceNode(self.llm)
+        self.consolidated_node=ConsolidatedNode()
+
+
+        self.graph_builder.add_node("userstories_generator",self.userstories_node.process)
+        self.graph_builder.add_node("human_fb_userstories", self.human_fb_userstories.process)
+        self.graph_builder.add_node("design_documents_generator",self.design_documents_node.process)
+        self.graph_builder.add_node("human_fb_design", self.human_fb_design.process)
+        self.graph_builder.add_node("design_summarizer", self.design_summarizer.process)
+        self.graph_builder.add_node("coder_subgraph",self.coder_subgraph.process)
+        self.graph_builder.add_node("human_fb_code", self.human_fb_code.process)
+        self.graph_builder.add_node("security_check_generator",self.security_check_node.process)
+        self.graph_builder.add_node("human_fb_review", self.human_fb_review.process)
+        self.graph_builder.add_node("test_cases_generator",self.test_cases_node.process)
+        self.graph_builder.add_node("human_fb_testcases",self.human_fb_testcases.process)
+        self.graph_builder.add_node("qa_testing_node",self.qa_testing_node.process)
+        self.graph_builder.add_node("human_fb_qatesting",self.human_fb_qatesting.process)
+        self.graph_builder.add_node("deployment_node",self.deployment_node.process)
+        self.graph_builder.add_node("monitoring_node",self.monitoring_node.process)
+        self.graph_builder.add_node("monitor_fb_node",self.monitor_fb_node.process)
+        self.graph_builder.add_node("maintanence_node",self.maintanence_node.process)
+        self.graph_builder.add_node("consolidated_node",self.consolidated_node.process)
+
+
+        self.graph_builder.add_edge(START,"userstories_generator")
+        self.graph_builder.add_edge("userstories_generator","human_fb_userstories")
+        self.graph_builder.add_conditional_edges("human_fb_userstories", 
+                                                 self.human_fb_userstories.user_story_review, 
+                                                 ["userstories_generator", "design_documents_generator"])
+        self.graph_builder.add_edge("design_documents_generator","human_fb_design")
+        self.graph_builder.add_conditional_edges("human_fb_design", 
+                                                 self.human_fb_design.design_document_review, 
+                                                 ["design_documents_generator", "design_summarizer"])
+        self.graph_builder.add_edge("design_summarizer","coder_subgraph")
+        self.graph_builder.add_edge("coder_subgraph","human_fb_code")
+        self.graph_builder.add_edge("human_fb_code","security_check_generator")
+        self.graph_builder.add_edge("security_check_generator","human_fb_review")
+        self.graph_builder.add_conditional_edges("human_fb_review", 
+                                                 self.human_fb_review.security_review, 
+                                                 ["security_check_generator", "test_cases_generator"])
+        self.graph_builder.add_edge("test_cases_generator","human_fb_testcases")
+        self.graph_builder.add_conditional_edges("human_fb_testcases", 
+                                                 self.human_fb_testcases.testcase_review, 
+                                                 ["test_cases_generator", "qa_testing_node"])
+        self.graph_builder.add_edge("qa_testing_node","human_fb_qatesting")
+        self.graph_builder.add_conditional_edges("human_fb_qatesting", 
+                                                 self.human_fb_qatesting.check_qa_response, 
+                                                 ["deployment_node", "coder_subgraph"])
+        self.graph_builder.add_edge("deployment_node","monitoring_node")
+        self.graph_builder.add_edge("monitoring_node","monitor_fb_node")
+        self.graph_builder.add_edge("monitor_fb_node","maintanence_node")
+        self.graph_builder.add_edge("maintanence_node","consolidated_node")
+        self.graph_builder.add_edge("consolidated_node",END)
+        
+
+    def setup_graph(self):
+        """
+        Sets up the graph 
+        """
+        self.build_graph()
+        #print("[DEBUG] Nodes in Graph:", self.graph_builder.nodes)
+        #assert "human_fb_code" in self.graph_builder.nodes, "[ERROR] human_fb_code is missing!"    
+        return self.graph_builder.compile(checkpointer=self.memory)
+
+    
+
+
+
+
+
+    

src/sdlc/graph/subgraph_builder.py

@@ -0,0 +1,51 @@
+from langgraph.graph import StateGraph, START,END
+from src.sdlc.states.states import CoderState
+from src.sdlc.nodes.code_orchestrator import CodeOrchestratorNode
+from src.sdlc.nodes.code_generation_node import CodeGenerationNode
+from src.sdlc.nodes.synthesizer_node import SynthesizerNode
+from src.sdlc.nodes.code_reviewer_node import CodeReviewerNode
+
+class SubGraphBuilder:
+
+    def __init__(self,model):
+        self.llm=model
+        self.graph_builder=StateGraph(CoderState)
+
+    def build_graph(self):
+        """
+        Builds a subgraph for code generation. 
+        """
+        self.code_orchestrator_node=CodeOrchestratorNode(self.llm)
+        self.code_generation_node=CodeGenerationNode(self.llm)
+        self.synthesizer_node=SynthesizerNode(self.llm)
+        self.code_reviewer_node=CodeReviewerNode(self.llm)
+        
+        self.graph_builder.add_node("code_orchestrator",self.code_orchestrator_node.process)
+        self.graph_builder.add_node("code_generation_node", self.code_generation_node.process)
+        self.graph_builder.add_node("code_synthesizer",self.synthesizer_node.process)
+        self.graph_builder.add_node("code_reviewer",self.code_reviewer_node.process)
+    
+
+        self.graph_builder.add_edge(START,"code_orchestrator")
+        self.graph_builder.add_conditional_edges("code_orchestrator", 
+                                                 self.code_orchestrator_node.assign_workers, 
+                                                 path_map=["code_generation_node"])
+        self.graph_builder.add_edge("code_generation_node", "code_synthesizer")
+        self.graph_builder.add_edge("code_synthesizer", "code_reviewer")
+        self.graph_builder.add_edge("code_reviewer", END)
+        
+
+    def setup_graph(self):
+        """
+        Sets up the graph 
+        """
+        self.build_graph()
+        return self.graph_builder.compile()
+
+    
+
+
+
+
+
+    

src/sdlc/main.py

@@ -0,0 +1,76 @@
+import streamlit as st
+from src.sdlc.ui.streamlitui.loadui import LoadStreamlitUI
+from src.sdlc.LLMS.groqllm import GroqLLM
+from src.sdlc.LLMS.openaillm import OpenAILLM
+from src.sdlc.ui.streamlitui.display_result import DisplayResultStreamlit
+from src.sdlc.ui.uiconfigfile import Config
+from src.sdlc.utils.utils import clear_cache_data
+from src.sdlc import logger
+
+
+def load_sdlc_app():
+    # Check if session state page exists
+    if "page" not in st.session_state:
+        st.session_state.page = "home"  # Default page
+    if st.session_state.page == "home": 
+      # Load UI
+      ui = LoadStreamlitUI()
+      user_input = ui.load_streamlit_ui()
+
+      # Title
+      st.title("🛠️ " + Config().get_page_title()) 
+      logger.info("In home page")
+
+      with st.form("sdlc_form"):          
+        # User Input for Requirements
+        user_requirements = st.text_area("📌 Enter your project requirements:")
+        if st.form_submit_button("🚀 Start SDLC Cycle") and user_requirements.strip():
+            try:
+                clear_cache_data() #Clear data from previous cycle
+                # Initialize LLM
+                st.session_state.selected_llm=user_input['selected_llm']
+                if user_input['selected_llm'] == 'Groq':
+                    obj_llm_config = GroqLLM(user_controls_input=user_input)
+                elif user_input['selected_llm'] == 'OpenAI':
+                    obj_llm_config = OpenAILLM(user_controls_input=user_input)
+                else:
+                    st.error("Invalid LLM selection.")
+                    return
+
+                model = obj_llm_config.get_llm_model()
+                if not model:
+                    st.error("Error: LLM model could not be initialized.")
+                    return
+
+                # Store values in session state
+                st.session_state.sdlc_started = True
+                st.session_state.user_input = user_input
+                st.session_state.user_requirements = user_requirements  # Store input
+
+                # Switch to the result page
+                st.session_state.page = "sdlc_result"
+                logger.info("Submitted user requirements: %s", user_requirements)
+                st.rerun()  # Re-run app to navigate
+
+            except Exception as e:
+                st.error(f"Error: {e}")
+    elif st.session_state.page == "sdlc_result": 
+        # Add a button to go back
+        if st.button("🔙 Restart SDLC Cycle"):
+                clear_cache_data()
+                st.rerun() 
+        
+        with st.spinner("Processing SDLC Results..."):         
+            # Call the DisplayResultStreamlit class
+            logger.info("Inside state page : ")
+            DisplayResultStreamlit().display_result_on_ui()
+        
+
+
+
+
+            
+            
+
+
+

src/sdlc/nodes/code_feedback.py

@@ -0,0 +1,42 @@
+from src.sdlc.states.states import State
+from langgraph.graph import END
+from langgraph.types import interrupt
+from src.sdlc import logger
+
+class CodeFeedback:
+    """
+    Node logic implementation matching your working UserStoriesFeedback pattern
+    """
+
+    def process(self, state: State):
+        """No-op node that gets interrupted"""
+        
+        logger.info("[DEBUG] Entering human_fb_code process")
+        human_code_review = interrupt(
+        {
+          "generated_code_review": state.get("generated_code_review","")
+        }
+        )
+        # Update the state with the human's input or route the graph based on the input.
+        logger.info(f"[DEBUG] Resuming human_fb_code process.Received code review : {human_code_review}")
+
+        return {
+            "generated_code_review": human_code_review
+        }
+    
+    # def code_file_review(self, state: State):
+    #     """Return the next node to execute based on review status"""
+    #     code_review = state.get('generated_code_review', '')
+    #     print("IN CODE REVIEW of Code Feedback:", code_review)
+        
+    #     # If we have review data, decide next step
+    #     if code_review:
+    #         # Assuming code_review is a dict with an 'approved' flag
+    #         # if code_review.get('approved', False):
+    #         #     return END  # Proceed to end if approved
+    #         print("Interrupting human feedback")
+    #         return "human_fb_code"  # Return for revisions if not approved
+        
+    #     # Default path when no review exists yet
+    #     return "security_review_node"
+    

src/sdlc/nodes/code_generation_node.py

@@ -0,0 +1,23 @@
+from src.sdlc.states.states import WorkerState
+from src.sdlc.prompts.prompts import CODE_GEN_INSTRUCTIONS
+from src.sdlc.schema.codefiles import CodeFile
+from src.sdlc import logger
+
+class CodeGenerationNode:
+    """
+    Node logic implementation to generate code for each code file type from orchestrator.
+    """
+    def __init__(self,model):
+        self.llm=model.with_structured_output(CodeFile)
+
+    def process(self, state: WorkerState) -> dict:
+        """
+        Processes the input state and generates code files.
+        """
+        code_review=state.get('generated_code_review', '')
+        code_file=self.llm.invoke(CODE_GEN_INSTRUCTIONS.format(code_review=code_review,
+                                                         codefilename=state['codefiletype'].name,
+                                                         codefiledescription=state['codefiletype'].description))
+        logger.info(f"In Code generation node for code file : {state['codefiletype'].name}")
+        return {"generated_files": [code_file]}
+

src/sdlc/nodes/code_orchestrator.py

@@ -0,0 +1,30 @@
+from src.sdlc.states.states import CoderState
+from src.sdlc.prompts.prompts import CODE_ORCHESTRATOR__INSTRNS
+from src.sdlc.schema.codefiletypes import CodeFileTypes
+from langgraph.constants import Send
+from src.sdlc import logger
+
+class CodeOrchestratorNode:
+    """Orchestrator that generates an architecture plan for the code"""
+
+    def __init__(self,model):
+        # Augment the LLM with schema for structured output
+        self.planner = model.with_structured_output(CodeFileTypes)
+
+    def process(self, state: CoderState):
+        """
+        Processes the input state and generates code file types.
+        """
+        response= self.planner.invoke(CODE_ORCHESTRATOR__INSTRNS.format(design_documents=state["design_summary"]))
+        logger.info(f"In orchestrator node, response is : {response.codefiletypes}")
+        return {"codefiletypes":response.codefiletypes}
+    
+    # Conditional edge function to create code_generation_node workers that each write each code file
+    def assign_workers(self,state: CoderState):
+        """Assign a worker to each code file in the plan"""
+        code_review=state.get('generated_code_review','')
+        logger.info("In orchestrator node, assigning workers for code files...")
+        # Kick off section writing in parallel via Send() API
+        return [Send("code_generation_node", {"generated_code_review":code_review,
+                                              "codefiletype": s}) for s in state["codefiletypes"]]
+    

src/sdlc/nodes/code_reviewer_node.py

@@ -0,0 +1,57 @@
+from src.sdlc.states.states import CoderState
+from src.sdlc.prompts.prompts import CODE_REVIEW_INSTRNS
+from src.sdlc.schema.codefiletypes import CodeFileTypes
+from src.sdlc import logger
+import time
+import groq
+
+class CodeReviewerNode:
+    """
+    Node logic implementation.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: CoderState):
+        """
+        Processes the input state and reviews the code based on the design documents.
+        Sends the files in batches of 3 for token limit management.
+        """
+        generated_code = state.get("generated_code", {})
+        design_summary = state["design_summary"]
+
+        # Convert the dictionary into a list of (filename, content) pairs
+        files_list = list(generated_code.items())
+
+        batch_size = 3
+        num_batches = min((len(files_list) + batch_size - 1) // batch_size, 4)  # Limit to 10 files 
+
+        all_reviews = []
+
+        for i in range(num_batches):
+            batch = dict(files_list[i * batch_size : (i + 1) * batch_size])  # Create a dictionary from the batch
+            try:
+                response = self.llm.invoke(CODE_REVIEW_INSTRNS.format(
+                    design_documents=design_summary,
+                    generated_code=batch
+                ))
+
+                logger.info(f"In code reviewer node. Batch {i+1} Response: {response.content}")
+                all_reviews.append(response.content)
+            except groq.RateLimitError as e:
+                wait_time = 70  # Wait a bit more than 1 minute
+                logger.info(f"Rate limit reached. Waiting for {wait_time} seconds...")
+                time.sleep(wait_time)  # Sleep and retry
+                response = self.llm.invoke(CODE_REVIEW_INSTRNS.format(
+                    design_documents=design_summary,
+                    generated_code=batch
+                ))
+                logger.info(f"Batch {i+1} Review after wait: ", response.content)
+                all_reviews.append(response.content)
+
+        # Combine all reviews into a single string
+        combined_review = "\n\n".join(all_reviews)
+
+        return {"generated_code_review": combined_review}
+
+    

src/sdlc/nodes/code_subgraph_node.py

@@ -0,0 +1,26 @@
+from src.sdlc.states.states import State
+from src.sdlc.graph.subgraph_builder import SubGraphBuilder
+from src.sdlc import logger
+
+class CoderSubgraphNode:
+    """
+    Node logic implementation.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    
+    def process(self, state: State):
+        """
+        Processes the input state and generates code files based on design documents.
+        """
+        sub_graph_builder = SubGraphBuilder(self.llm)
+        self.sub_graph = sub_graph_builder.setup_graph()
+        
+        design = state["design_summary"]
+        # Now execute the subgraph
+        response = self.sub_graph.invoke({"design_summary": design}) 
+        logger.info("INVOKING SUBGRAPH FOR CODE GENERATION...")
+        return response
+
+    

src/sdlc/nodes/consolidated_node.py

@@ -0,0 +1,15 @@
+from src.sdlc.states.states import State
+from src.sdlc import logger
+
+class ConsolidatedNode:
+    """
+    Node logic implementation.
+    """
+
+    def process(self, state: State) -> dict:
+        """
+        Gets all artifacts from state to display.
+        """
+        logger.info("IN CONSOLIDATED NODE,displaying artifacts...")
+        return {"consolidated_artifacts":"Display artifacts"}
+    

src/sdlc/nodes/deployment_node.py

@@ -0,0 +1,20 @@
+from src.sdlc.states.states import State
+from src.sdlc.prompts.prompts import DEPLOYMENT_INSTRUCTIONS
+from src.sdlc import logger
+
+class DeploymentNode:
+    """
+    Node logic implementation.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State) -> dict:
+        """
+        Processes the input state and generates deployment instructions based on design document.
+        """
+        design_summary=state.get('design_summary', '')
+        response=self.llm.invoke(DEPLOYMENT_INSTRUCTIONS.format(design_document=design_summary))
+        logger.info(f"In DEPLOYMENT NODE ,response received")
+        return {"deployment":response.content}
+    

src/sdlc/nodes/design_documents_feedback.py

@@ -0,0 +1,35 @@
+from src.sdlc.states.states import State
+from langgraph.graph import END
+from langgraph.types import interrupt
+from src.sdlc import logger
+
+class DesignDocumentsFeedback:
+    """
+    Node logic implementation.
+    """
+    def process(self, state: State):
+        """ No-op node that should be interrupted on """
+        logger.info("[DEBUG] Entering human_fb_design process")
+        human_design_review = interrupt(
+        {
+          "design_documents_review": state.get('design_documents_review', "")
+        }
+        )
+        # Update the state with the human's input or route the graph based on the input.
+        logger.info(f"RESUMING DESIGN FEEDBACK NODE, feedback received : {human_design_review}")
+        return {
+            "design_documents_review": human_design_review
+        }
+    
+    def design_document_review(self,state: State):
+        """ Return the next node to execute """
+        # Check if human feedback
+        design_review=state.get('design_documents_review', "")
+        logger.info("IN DESIGN REVIEW, determining flow based on design review...")
+        if design_review:
+            return "design_documents_generator"
+        
+        # Otherwise summarize design docs
+        else:
+            return "design_summarizer"
+

src/sdlc/nodes/design_documents_node.py

@@ -0,0 +1,30 @@
+from src.sdlc.states.states import State
+from src.sdlc.prompts.prompts import DESIGNDOCS_GEN_INSTRNS,DESIGN_MODIFY_INSTRNS
+from src.sdlc import logger
+
+class DesignDocumentsNode:
+    """
+    Node logic implementation.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State):
+        """
+        Processes the input state and generates design document based on user stories.
+        """
+        design_review=state.get("design_documents_review", "")
+        design_doc=state.get("design_documents", "")
+        if design_review:
+            response=self.llm.invoke(DESIGN_MODIFY_INSTRNS.format(design_review=design_review,
+                                                            design_documents=design_doc))
+            logger.info("IN MODIFY DESIGN DOCS...")
+        else:
+            response=self.llm.invoke(DESIGNDOCS_GEN_INSTRNS.format(user_stories=state["user_stories"],
+                                                                design_documents=design_doc,
+                                                                design_review=design_review))
+            logger.info("IN DESIGN DOCS GENERATION...")
+        return {"design_documents":response.content}
+    
+
+    

src/sdlc/nodes/design_summarize.py

@@ -0,0 +1,20 @@
+from src.sdlc.states.states import State
+from src.sdlc.prompts.prompts import SUMMARIZE_DESIGN_DOCS
+from src.sdlc import logger
+
+class DesignSummarizeNode:
+    """
+    Node logic implementation.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State):
+        """
+        Processes the input state and generates design document based on user stories.
+        """
+        #Summarize the design documents for the code generation
+        summarized_docs=self.llm.invoke(SUMMARIZE_DESIGN_DOCS.format(design_documents=state["design_documents"]))
+        logger.info(f"In DESIGN SUMMARIZN NODE,response received  : {summarized_docs.content}")
+        return {"design_summary": summarized_docs.content}
+    

src/sdlc/nodes/maintanence_node.py

@@ -0,0 +1,20 @@
+from src.sdlc.states.states import State
+from src.sdlc.prompts.prompts import MAINTANENCE_INSTRNS
+from src.sdlc import logger
+
+class MaintanenceNode:
+    """
+    Node logic implementation.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State) -> dict:
+        """
+        Processes the input state and generates maintanence instructions based on design.
+        """
+        monitoring_feedback=state.get('monitoring_and_feedback_review', '')
+        response=self.llm.invoke(MAINTANENCE_INSTRNS.format(user_feedback=monitoring_feedback))
+        logger.info(f"In MAINTANENCE NODE, received response")
+        return {"maintanence_and_updates":response.content}
+    

src/sdlc/nodes/monitor_fb_node.py

@@ -0,0 +1,27 @@
+from src.sdlc.states.states import State
+from langgraph.graph import END
+from langgraph.types import interrupt
+from src.sdlc import logger
+
+class MonitorFeedback:
+    """
+    Node logic implementation.
+    """
+
+    def process(self, state: State):
+        """ No-op node that should be interrupted on """
+        logger.info("[DEBUG] Entering human_fb_monitoring process")
+
+        human_monitoring_fb= interrupt(
+        {
+          "monitoring_and_feedback_review": state.get('monitoring_and_feedback_review', "")
+        }
+        )
+        # Update the state with the human's input or route the graph based on the input.
+        logger.info(f"RESUMING MONITORING FEEDBACK NODE,feedback received : {human_monitoring_fb}")
+        
+        return {
+            "monitoring_and_feedback_review": human_monitoring_fb
+        }
+    
+

src/sdlc/nodes/monitoring_node.py

@@ -0,0 +1,20 @@
+from src.sdlc.states.states import State
+from src.sdlc.prompts.prompts import MONITORING_FB_INSTRNS
+from src.sdlc import logger
+
+class MonitoringNode:
+    """
+    Node logic implementation.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State) -> dict:
+        """
+        Processes the input state and generates monitoring and feedback instructions based on deployment.
+        """
+        deployment_instructions=state.get('deployment', '')
+        response=self.llm.invoke(MONITORING_FB_INSTRNS.format(deployment_instructions=deployment_instructions))
+        logger.info(f"In GEN MONITORING AND FEEDBACK INSTRUCTIONS,response received...")
+        return {"monitoring_and_feedback":response.content}
+    

src/sdlc/nodes/qa_feedback.py

@@ -0,0 +1,29 @@
+from src.sdlc.states.states import State
+from langgraph.graph import END
+from langgraph.types import interrupt
+from src.sdlc import logger
+
+class QAFeedback:
+    """
+    Node logic implementation.
+    """
+    def process(self, state: State):
+        """ No-op node that should be interrupted on """
+        logger.info("[DEBUG] Entering human_fb_qatesting process")
+        qa_result = interrupt(
+        {
+          "qa_result": state.get('qa_testing', "")
+        }
+        )
+        # Update the state with the human's input or route the graph based on the input.
+        logger.info(f"RESUMING QATESTING FEEDBACK NODE ,qa etsting result : {qa_result['result']}")
+        return {
+            "qa_status": qa_result["result"]
+        }
+    
+    def check_qa_response(self,state):
+        qa_status=state.get("qa_status","")
+        if qa_status=="Passed":
+            return "deployment_node"
+        else:
+            return "coder_subgraph"

src/sdlc/nodes/qatesting_node.py

@@ -0,0 +1,167 @@
+from src.sdlc.states.states import State
+from src.sdlc.prompts.prompts import TESTCASES_GEN_INSTRNS
+from src.sdlc import logger
+import traceback
+from typing import List, Tuple, Dict
+import re
+import io
+import contextlib
+from copy import deepcopy
+
+
+class QATestingNode:
+    """
+    Node logic implementation for QA Testing.
+    """
+
+    @staticmethod
+    def markdown_test_cases_to_python(markdown: str) -> Tuple[str, List[Dict]]:
+        lines = markdown.strip().split("\n")
+        data_lines = [line.strip() for line in lines if line.strip()]
+        header_index = next((i for i, line in enumerate(data_lines) if "---" in line), None)
+
+        if header_index is None or header_index == 0:
+            raise ValueError("Markdown table is malformed or missing header separator.")
+
+        headers = [h.strip() for h in data_lines[0].split('|')[1:-1]]
+        rows = data_lines[header_index + 1:]
+
+        test_funcs: List[str] = []
+        metadata: List[Dict] = []
+
+        for row in rows:
+            columns = [col.strip() for col in row.split('|')[1:-1]]
+            if len(columns) != len(headers):
+                continue
+
+            case_id, use_case, scenario, steps, expected, test_type = columns
+            func_name = re.sub(r'\W+', '_', f"test_{case_id}_{use_case}_{scenario}").lower()
+            step_lines = steps.replace("<br>", "\n").split("\n")
+            step_code = "\n    ".join(f"# {step.strip()}" for step in step_lines)
+            expected_comment = f"# Expected: {expected}"
+
+            test_func = f"""
+            def {func_name}():
+                {step_code}
+                {expected_comment}
+                print("Simulated Output for: {expected}")  # Add dummy output
+                assert True  # TODO: Replace with real assertion
+            """
+            test_funcs.append(test_func.strip())
+
+            metadata.append({
+                "func_name": func_name,
+                "Test Case ID": case_id,
+                "Use Case": use_case,
+                "Test Scenario": scenario,
+                "Test Steps": steps,
+                "Expected Result": expected,
+                "Test Type": test_type
+            })
+
+        return "\n\n".join(test_funcs), metadata
+
+    def process(self, state):
+        generated_code = state.get("generated_code", {})
+        test_cases_markdown = state.get("test_cases", "")
+
+        overall_results = []
+
+        # Parse test cases once
+        try:
+            test_code, metadata = QATestingNode.markdown_test_cases_to_python(test_cases_markdown)
+        except Exception:
+            return {
+                "qa_testing": {
+                    "result":"Failed",
+                    "summary": "❌ Failed to parse test cases.",
+                    "table": "",
+                    "details": [{
+                        "Test Case ID": "Unknown",
+                        "Use Case": "Global",
+                        "Test Scenario": "Test case markdown parsing failed",
+                        "Test Steps": "-",
+                        "Expected Result": "-",
+                        "Actual Output": "-",
+                        "Test Type": "-",
+                        "Status": "❌ Fail",
+                        "Error": traceback.format_exc()
+                    }]
+                }
+            }
+
+        # ✅ One shared environment
+        local_env = {}
+        try:
+            # Load all code files into same namespace
+            for file_path, code in generated_code.items():
+                if not file_path.endswith(".py"):
+                    logger.warning(f"Skipping non-Python file: {file_path}")
+                    continue
+                try:
+                    exec(code, local_env)
+                except Exception as e:
+                    logger.error(f"Failed to exec {file_path}: {e}")
+
+            exec(test_code, local_env)
+
+            for test_meta_orig in metadata:
+                test_meta = deepcopy(test_meta_orig)
+                func_name = test_meta.get("func_name")
+
+                try:
+                    test_func = local_env.get(func_name)
+                    if not test_func:
+                        raise ValueError(f"Function '{func_name}' not found")
+
+                    # Capture stdout
+                    f = io.StringIO()
+                    with contextlib.redirect_stdout(f):
+                        result = test_func()
+                    output = f.getvalue().strip()
+                    test_meta["Actual Output"] = output or str(result)
+                    test_meta["Status"] = "✅ Pass"
+
+                except Exception:
+                    test_meta["Actual Output"] = "-"
+                    test_meta["Status"] = "❌ Fail"
+                    test_meta["Error"] = traceback.format_exc()
+
+                overall_results.append(test_meta)
+
+        except Exception:
+            for test_meta_orig in metadata:
+                test_meta = deepcopy(test_meta_orig)
+                test_meta["Status"] = "❌ Fail"
+                test_meta["Actual Output"] = "-"
+                test_meta["Error"] = traceback.format_exc()
+                overall_results.append(test_meta)
+
+        # Markdown table generation
+        table_header = (
+            "| Test Case ID | Use Case | Test Scenario | Test Steps | Expected Result | Actual Output | Test Type | Status |\n"
+            "| --- | --- | --- | --- | --- | --- | --- | --- |\n"
+        )
+
+        table_rows = ""
+        for r in overall_results:
+            table_rows += (
+                f"| {r.get('Test Case ID')} | {r.get('Use Case')} | {r.get('Test Scenario')} | "
+                f"{r.get('Test Steps')} | {r.get('Expected Result')} | {r.get('Actual Output')} | "
+                f"{r.get('Test Type')} | {r.get('Status')} |\n"
+            )
+
+        markdown_table = table_header + table_rows
+        summary = "✅ All tests passed" if all(r["Status"] == "✅ Pass" for r in overall_results) else "❌ Some tests failed"
+        logger.info(f"IN QA TESTING NODE, results : {summary}")
+        return {
+            "qa_testing": {
+                "result":"Passed",
+                "summary": summary,
+                "table": markdown_table,
+                "details": overall_results
+            }
+        }
+    
+
+

src/sdlc/nodes/security_check_node.py

@@ -0,0 +1,25 @@
+from src.sdlc.states.states import State
+from src.sdlc.prompts.prompts import SECURITY_REVIEW_INSTRNS
+from src.sdlc import logger
+
+class SecurityCheckNode:
+    """
+    Node logic implementation.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State):
+        """
+        Processes the input state and reviews the code for security.
+        """
+        generated_code=state.get('generated_code', '')
+        
+        response=self.llm.invoke(SECURITY_REVIEW_INSTRNS.format(generated_code=generated_code))
+        logger.info("In SECURITY CHECK NODE,received response")
+        return {"security_check":response.content}
+
+
+    
+
+    

src/sdlc/nodes/security_feedback.py

@@ -0,0 +1,35 @@
+from src.sdlc.states.states import State
+from langgraph.graph import END
+from langgraph.types import interrupt
+from src.sdlc import logger
+
+class SecurityReviewFeedback:
+    """
+    Node logic implementation.
+    """
+
+    def process(self, state: State):
+        """ No-op node that should be interrupted on """
+        logger.info("[DEBUG] Entering human_fb_review process")
+        human_security_review = interrupt(
+        {
+          "security_check_review": state.get("security_check_review","")
+        }
+        )
+        # Update the state with the human's input or route the graph based on the input.
+        logger.info(f'RESUMING SECURITY FEEDBACK NODE, feedback is {human_security_review}')
+        return {
+            "security_check_review": human_security_review
+        }
+    
+    def security_review(self,state: State):
+        """ Return the next node to execute """
+        # Check if human feedback
+        security_check_review=state.get('security_check_review', "")
+        logger.info("IN SECURITY REVIEW, determining flow...")
+        if security_check_review:
+            return "security_check_generator"
+        
+        # Otherwise 
+        return "test_cases_generator"
+

src/sdlc/nodes/synthesizer_node.py

@@ -0,0 +1,27 @@
+from src.sdlc.states.states import CoderState
+from src.sdlc.prompts.prompts import FILE_MODIFY_INSTRNS
+from src.sdlc.schema.codefiletypes import CodeFileTypes
+from src.sdlc import logger
+
+class SynthesizerNode:
+    """Node logic implementation for synthesizing full code from multiple files."""
+
+    def __init__(self, model):
+        self.llm = model.with_structured_output(CodeFileTypes)
+
+    def process(self, state: CoderState):
+        """Synthesize full code from multiple generated files."""
+        #expected_files = state["codefiletypes"]  # List of expected file types
+        generated_files = state.get("generated_files", [])
+
+        logger.info(f"IN code_synthesizer, generated code files : {generated_files}")
+
+        # Wait for all expected files before proceeding
+        # if len(generated_files) < len(expected_files):
+        #     print(f"⚠️ Waiting for all generated files. Current: {len(generated_files)}, Expected: {len(expected_files)}")
+        #     return  # Do nothing, let LangGraph retry when more data arrives
+
+        # Convert to dictionary format: {filename: code}
+        generated_code = {code_file.name: code_file.code for code_file in generated_files}
+
+        return {"generated_code": generated_code}

src/sdlc/nodes/test_cases_feedback.py

@@ -0,0 +1,35 @@
+from src.sdlc.states.states import State
+from langgraph.graph import END
+from langgraph.types import interrupt
+from src.sdlc import logger
+
+class TestCasesFeedback:
+    """
+    Node logic implementation.
+    """
+
+    def process(self, state: State):
+        """ No-op node that should be interrupted on """
+        logger.info("[DEBUG] Entering human_fb_testcases process")
+        human_testcases_review = interrupt(
+        {
+          "test_cases_review": state.get("test_cases_review","")
+        }
+        )
+        # Update the state with the human's input or route the graph based on the input.
+        logger.info(f'RESUMING TEST CASES FEEDBACK NODE, feedback received : {human_testcases_review}')
+        return {
+            "test_cases_review": human_testcases_review
+        }
+    
+    def testcase_review(self,state: State):
+        """ Return the next node to execute """
+        # Check if human feedback
+        test_cases_review=state.get('test_cases_review', "")
+        logger.info("IN TEST CASE REVIEW,determining flow...")
+        if test_cases_review:
+            return "test_cases_generator"
+        
+        # Otherwise 
+        return "qa_testing_node"
+

src/sdlc/nodes/test_cases_node.py

@@ -0,0 +1,24 @@
+from src.sdlc.states.states import State
+from src.sdlc.prompts.prompts import TESTCASES_GEN_INSTRNS
+from src.sdlc import logger
+
+class TestCasesNode:
+    """
+    Node logic implementation.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State):
+        """
+        Processes the input state and generates test cases for the code
+        """
+        design_summary=state.get('design_summary', '')        
+        response=self.llm.invoke(TESTCASES_GEN_INSTRNS.format(design_documents=design_summary))
+        logger.info("In TEST CASES NODE received response")
+        return {"test_cases":response.content}
+
+
+    
+
+    

src/sdlc/nodes/userstories_feedback.py

@@ -0,0 +1,37 @@
+from src.sdlc.states.states import State
+from langgraph.graph import END
+from langgraph.types import interrupt
+from src.sdlc import logger
+
+class UserStoriesFeedback:
+    """
+    Node logic implementation.
+    """
+
+    def process(self, state: State):
+        """ No-op node that should be interrupted on """
+        logger.info("[DEBUG] Entering human_fb_user stories process")
+
+        human_userstory_review = interrupt(
+        {
+          "user_stories_review": state.get('user_stories_review', "")
+        }
+        )
+        # Update the state with the human's input or route the graph based on the input.
+        logger.info(f'RESUMING HUMAN USERSTORIES FEEDBACK NODE, feedback is : {human_userstory_review}')
+        
+        return {
+            "user_stories_review": human_userstory_review
+        }
+    
+    def user_story_review(self,state: State):
+        """ Return the next node to execute """
+        # Check if human feedback
+        user_stories_review=state.get('user_stories_review', "")
+        logger.info("IN USER STORY REVIEW,determining flow...")
+        if user_stories_review:
+            return "userstories_generator"
+        
+        # Otherwise design_documents_node
+        return "design_documents_generator"
+

src/sdlc/nodes/userstories_node.py

@@ -0,0 +1,27 @@
+from src.sdlc.states.states import State
+from src.sdlc.prompts.prompts import USERSTORY_GEN_INSTRNS,USERSTORY_MODIFY_INSTRNS
+from src.sdlc import logger
+
+class UserStoriesNode:
+    """
+    Node logic implementation.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State) -> dict:
+        """
+        Processes the input state and generates user stories based on user requirements.
+        """
+        user_stories_review=state.get('user_stories_review', '')
+        user_stories=state.get('user_stories', '')
+        if user_stories_review:
+            response=self.llm.invoke(USERSTORY_MODIFY_INSTRNS.format(user_stories_review=user_stories_review,
+                                                            user_stories=user_stories))
+            logger.info("IN MODIFY USER STORIES")
+        else:
+            response=self.llm.invoke(USERSTORY_GEN_INSTRNS.format(user_requirements=state["user_requirements"],
+                                                            user_stories=user_stories))
+            logger.info("In GENERATE USER STORIES...")
+        return {"user_stories":response.content}
+    

src/sdlc/prompts/prompts.py

@@ -0,0 +1,266 @@
+USERSTORY_GEN_INSTRNS="""You are tasked with creating a detailed user story based on the given user requirements.
+Provide a single title for the user story and add all details expected from the requirements. Follow these instructions carefully:
+
+1. **Review** the given user requirements carefully:
+{user_requirements}
+
+2. **Format the output using Markdown**.
+
+3. **Do not include any preamble** before listing the user stories.
+"""
+USERSTORY_MODIFY_INSTRNS="""You are tasked with modifying the existing user stories based on the given user feedback.
+Follow these instructions carefully:
+
+1. Modify the already generated user stories  based on editorial feedback.Keep the general outline of the already generated user stories :
+   - Previously generated user stories:  
+   {user_stories}  
+   - Editorial feedback:  
+   {user_stories_review}
+
+2. **Format the output using Markdown**.
+
+3. **Do not include any preamble** before listing the user stories.
+"""
+
+DESIGNDOCS_GEN_INSTRNS="""
+You are tasked with creating a **comprehensive design document** based on the given user stories. Follow these instructions carefully:  
+
+1. **Review the given user stories carefully:**  
+   {user_stories}  
+
+2. **Structure the design document as follows:**  
+   - **Introduction:** Provide a high-level summary of the system.  
+   - **System Overview:** Describe the core functionality and scope.  
+   - **Functional Requirements:** List detailed functional requirements derived from the user stories.  
+   - **Use Cases:** Define key use cases and user interactions with the system.  
+   - **Architecture Design:** Include a high-level architecture diagram in Markdown mermaid format.  
+   - **Technology Stack:** Specify the programming languages, frameworks, and tools used.  
+   - **Database Schema:** Define tables, relationships, and key constraints.  
+   - **API Specifications:** Outline RESTful or GraphQL endpoints with request/response formats.  
+   - **Deployment Strategy:** Explain CI/CD pipelines, hosting, and cloud infrastructure.  
+   - **Security Considerations:** Detail authentication, authorization, and data protection measures.  
+   - **Code Considerations:** Describe how the front-end and back-end code will be structured.  
+
+3. **Return the final software design document in Markdown format.**  
+   - Embed the **architecture diagram** as a Mermaid diagram.  
+   - Ensure it covers all coding aspects, including front-end and back-end implementation details.  
+
+"""
+
+DESIGN_MODIFY_INSTRNS="""You are tasked with modifying the existing design documents based on the given user feedback.
+Follow these instructions carefully:
+
+1. Modify the already generated design documents based on editorial feedback.Keep the general outline of the already generated design documents :
+   - Previously generated design documents:  
+   {design_documents}  
+   - Editorial feedback:  
+   {design_review}
+
+2. **Format the output using Markdown**.
+
+3. **Do not include any preamble** before listing the design documents.
+"""
+
+
+CODE_ORCHESTRATOR__INSTRNS="""
+Generate a production-level code architecture plan based on the provided design document : {design_documents}.
+Follow these instructions carefully to ensure a structured and well-organized folder hierarchy:
+1. Define the sub folder structure based on the design documents for placing files of related functionalities.
+2. Determine file structure: Generate unique file names with appropriate extensions based on all functionalities specified in the design document.Limit the number of files to 10 or lower as applicable.
+3. Group related files into subfolders based on their functionality.
+4. Ensure correct naming convention:
+- For each file, include its full path within the "name" key 
+- Ensure every file is assigned to a subfolder when applicable.Multiple files can come under a single subfolder.
+- Try to limit subfolder count to maximum of 5 or lower as applicable
+5. Provide meaningful descriptions: Each file should have a clear and concise description under the "description" key, explaining its purpose and role in the system.
+6. Output format: Return a JSON object containing multiple file entries, each with "name" and "description" keys for multiple files
+7. Production-ready best practices: Ensure the folder structure is scalable, modular, aligning with industry standards for production environments.
+"""
+
+CODE_GEN_INSTRUCTIONS="""
+Generate code contents for the code file based on the details given  file name: {codefilename} and description: {codefiledescription}.
+Follow the below instructions carefully.
+1. Check for any optional feedback {code_review} and generate the code accordingly.
+2. Return the 'name' and 'code' for the file in JSON format.
+"""
+
+FILE_MODIFY_INSTRNS="""
+Examine the code review feedback provided :{code_review}.
+The existing code file names with the descriptions is as provided : {codefiletypes}
+Identify the code file names that need modifications based on the descriptions and feedback provided.
+If feedback requires new files to be added,provide file name and description accordingly.
+Return the files to be modified with names and descriptions as a JSON object 
+"""
+
+SUMMARIZE_DESIGN_DOCS="""
+Summarize the following **detailed design document** : {design_documents} to extract only the most relevant information for code review.
+### **Output Format**
+Provide a structured summary focusing on:
+1. **System Overview**: A brief summary of the system’s purpose and functionality.
+2. **Functional Requirements**: Key expected features and functionalities.
+3. **Technical Requirements**: Technologies, frameworks, database structures, and any architectural constraints.
+4. **Code Structure**: Expected file organization, naming conventions, and module breakdown.
+5. **Security & Performance Considerations**: Any key performance optimizations or security best practices.
+
+Return the response in **concise bullet points** to facilitate quick comparison with the generated code.Limit the word count to a maximum of 500 and make it concise.
+"""
+
+CODE_REVIEW_INSTRNS = """
+You are reviewing the generated code to ensure it aligns with the design document: {design_documents}. 
+Identify discrepancies, suggest modifications, and determine if new files are required based on the already generated code: {generated_code}.
+
+Follow the below instructions:
+1. Compare the generated code against the design document to identify any missing, incorrect, or incomplete implementations.
+2. Ensure all functionalities described in the design document are correctly implemented.
+3. Verify adherence to architecture, logic, and expected behavior.
+4. Determine required modifications or if any functionality is missing. List the file names that need modifications and clearly describe the required changes.
+5. Do not use Markdown formatting, bullet points, titles, or special characters. Provide a clear, structured response in plain text.
+6. Output format:
+   - List the names of the files that need modifications.
+   - Provide a clear explanation of the issues in each file.
+   - Describe specifically what needs to be added, removed, or changed.
+   - Use simple sentences and paragraphs without special formatting.
+"""
+
+SECURITY_REVIEW_INSTRNS="""
+You are a security expert tasked with reviewing the security of a set of generated code files : {generated_code} where
+
+- The keys represent file names with extensions (e.g., "app.py", "index.js", "config.yaml").
+- The values contain the source code of each file.
+
+Your task:
+1. Analyze each file for security vulnerabilities.
+2. Identify common security risks, including but not limited to:
+   - Hardcoded credentials, API keys, or secrets.
+   - Injection vulnerabilities (SQL injection, command injection, XSS, etc.).
+   - Insecure authentication or missing authorization checks.
+   - Use of outdated or vulnerable dependencies.
+   - Weak cryptographic practices.
+   - Improper input validation and sanitization.
+   - Insecure file handling or deserialization risks.
+   - Lack of logging or excessive logging of sensitive data.
+   - Misconfigured security settings in configuration files.
+
+Format your response in **Markdown** without any preamble:
+"""
+
+TESTCASES_GEN_INSTRNS="""
+You are an expert in software testing and test case generation. Given a design document containing functional, technical, and structural requirements, generate a consolidated test case table. Each test case should include key attributes like test scenario, test steps, expected result, and test type.
+
+Input:
+The design document contains the following details:{design_documents}
+
+Functional Requirements - Describe how the system should behave.
+
+Technical Requirements - Specify implementation details, integrations, and constraints.
+
+Structural Requirements - Define architectural and infrastructure-level details.
+
+Output Format (Table Format) without a preamble:
+Provide a structured response in a tabular format with the following columns:
+
+Test Case ID - Unique identifier for the test case.
+
+Use Case - The specific use case being tested.
+
+Test Scenario - A brief description of what is being tested.
+
+Test Steps - Step-by-step procedure to execute the test.
+
+Expected Result - The anticipated system behavior after execution.
+
+Test Type - Functional, Integration, Structural, or Performance.
+"""
+
+DEPLOYMENT_INSTRUCTIONS="""
+You are an SDLC deployment assistant. You will be given a software design document.
+
+Your task is to:
+
+1. **Analyze the document** and determine if it includes any deployment-related preferences or decisions. Look for:
+   - Platforms (e.g., AWS, Heroku, Vercel, Netlify, Docker, Kubernetes, etc.)
+   - Hosting types (e.g., static, containerized, serverless)
+   - Infrastructure details (e.g., EC2, S3, Cloud Run, etc.)
+   - CI/CD or version control notes relevant to deployment
+
+2. If **deployment is mentioned**, extract the method or platform clearly.
+
+3. If **no deployment is mentioned**, pick a **suitable and commonly used deployment platform at random** (such as Heroku, Netlify, or AWS EC2) based on the application's likely needs.
+
+4. Provide **clear deployment steps** for the identified or assumed deployment method.
+
+### Input:
+{design_document}
+
+### Output:
+- **Detected or Assumed Deployment Method:** <deployment_type_or_platform>
+- **Deployment Steps:**
+  1. ...
+  2. ...
+  3. ...
+
+"""
+
+MONITORING_FB_INSTRNS="""
+You are an experienced DevOps and SRE (Site Reliability Engineering) expert.
+
+Below are the deployment instructions for a software application. Your task is to generate actionable, concise, and technically sound instructions for:
+
+1. **Monitoring** the system after deployment.
+2. **Collecting and analyzing feedback**, including error logs, user input, and performance metrics.
+
+---  
+### Deployment Instructions:
+{deployment_instructions}
+
+---
+
+### Output Format:
+
+## Monitoring Instructions
+- (bullet point list of what and how to monitor based on deployment details)
+
+## Feedback Collection Instructions
+- (bullet point list of how feedback should be collected and reviewed post-deployment)
+
+Focus on tools, logs, services, metrics, and automation where applicable.
+
+"""
+
+MAINTANENCE_INSTRNS="""
+You are assisting with software maintenance based on user feedback.
+
+Optional Feedback Received:
+{user_feedback}
+If no feedback received, respond that no user feedback for maintanence received and generate a project-specific maintenance plan.
+Else, if feedback received,based on this feedback, analyze the likely issue and generate a project-specific maintenance plan that includes:
+
+- Summary of the problem
+
+- Likely cause or affected area
+
+- Recommended fix or update
+
+- Tests or documentation to update
+
+- Any potential security or deployment impact
+
+Output is in markdown format as follows:
+
+## Maintenance Plan
+
+### User Feedback
+"{user_feedback}"
+
+### Likely Cause
+...
+
+### Suggested Fix or Update
+...
+
+### Tests & Docs
+...
+
+### Security / Deployment Notes
+...
+"""

src/sdlc/schema/codefiles.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel,Field
+from typing import List
+
+# Schema for structured output to use in planning
+class CodeFile(BaseModel):
+    name: str = Field(
+        description="Name of the code file with extension",
+    )
+    code: str = Field(
+        description="Code content of the file",
+    )
+
+class CodeFiles(BaseModel):
+    codefiles: List[CodeFile] = Field(
+        description="List of code files.",
+    )

src/sdlc/schema/codefiletypes.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel,Field
+from typing import List
+
+class CodeFileType(BaseModel):
+    name: str = Field(
+        description="Name of the code file with extension",
+    )
+    description: str = Field(
+        description="Description of the functionality in the file",
+    )
+
+class CodeFileTypes(BaseModel):
+    codefiletypes: List[CodeFileType] = Field(
+        description="List of code files.",
+    )
+

src/sdlc/states/states.py

@@ -0,0 +1,50 @@
+from typing import Annotated, Literal, Optional
+from typing_extensions import TypedDict
+from typing import TypedDict, Annotated, List,Dict
+from src.sdlc.schema.codefiletypes import CodeFileType
+from src.sdlc.schema.codefiles import CodeFile
+import operator
+
+class State(TypedDict):
+    user_requirements:str
+    user_stories:str
+    user_stories_review:str
+    design_documents:str
+    design_documents_review:str
+    design_summary:str
+    codefiletypes: List[CodeFileType]
+    generated_files: Annotated[
+        List[CodeFile], operator.add
+    ]  # All workers write to this key in parallel
+    generated_code: Dict 
+    generated_code_review:str
+    security_check:str
+    security_check_review:str
+    test_cases:str
+    test_cases_review:str
+    qa_testing:Dict
+    qa_status:str
+    deployment:str
+    monitoring_and_feedback:str
+    monitoring_and_feedback_review:str
+    maintanence_and_updates:str
+    consolidated_artifacts:Dict
+
+# Subgraph state
+class CoderState(TypedDict):
+    design_summary:str
+    codefiletypes: List[CodeFileType]
+    generated_files: Annotated[
+        List[CodeFile], operator.add
+    ]  # All workers write to this key in parallel
+    generated_code: Dict 
+    generated_code_review:str
+    security_review:str
+
+
+# Worker state
+class WorkerState(TypedDict):
+    codefiletype: CodeFileType
+    code_review:str
+    security_review:str
+    generated_files: Annotated[List[CodeFile], operator.add]

src/sdlc/ui/streamlitui/display_artifacts.py

@@ -0,0 +1,28 @@
+import streamlit as st
+from src.sdlc.utils.utils import display_states
+import base64
+import json
+
+def display_downloads(self):
+    state = self.graph.get_state(config=st.session_state.thread)  # Fetch the state from the graph
+    state_dict = state.values  
+    st.write("### Downloadable assets from the SDLC")
+    for key, value in state_dict.items():
+        if key=="generated_code":
+            # Convert ZIP to base64
+            zip_bytes = st.session_state.zip_buffer.getvalue()
+            b64_zip = base64.b64encode(zip_bytes).decode()
+            # Create a download link
+            href = f'''<a href="data:application/zip;base64,{b64_zip}" 
+            download="generated_code.zip" 
+            style="text-decoration: none; color: inherit; font-weight: bold;">⬇️ Download code files</a>'''
+            st.markdown(href, unsafe_allow_html=True) 
+        elif key=="qa_testing":
+            #Convert the list to a JSON string
+            json_str = json.dumps(value['details'])
+            display_states(self.curr_state, json_str)
+        elif key in self.sdlc_nodes and key !="consolidated_artifacts":
+            display_states(key,value)
+
+
+    

src/sdlc/ui/streamlitui/display_code.py

@@ -0,0 +1,60 @@
+import streamlit as st
+from langgraph.types import Command
+import zipfile
+import io
+
+def create_zip(generated_code):
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
+        for file_path, code_content in generated_code.items():
+            zip_file.writestr(file_path, code_content)
+    zip_buffer.seek(0)
+    return zip_buffer
+
+def display_code_files(self, generated_code):
+    st.title("Generated Code Review")
+
+    st.subheader("📄 Generated Code Files")
+
+    # Display all code files
+    for file_path, code_content in generated_code.items():
+        st.markdown(f"**`{file_path}`**")
+        st.code(code_content, language="python")  # adjust language as needed
+
+    # Create ZIP only once
+    if "zip_buffer" not in st.session_state:
+        st.session_state.zip_buffer = create_zip(generated_code)
+
+    # Download button
+    st.download_button(
+        label="⬇️ Download All as ZIP",
+        data=st.session_state.zip_buffer,
+        file_name="generated_code.zip",
+        mime="application/zip"
+    )
+
+    # Inline Approve + Feedback Form
+    st.divider()
+
+    with st.form(key="approve_feedback_form"):
+        col1, col2 = st.columns([1, 4])  # Adjust ratio as needed
+
+        with col1:
+            approve = st.form_submit_button("✅ Approve")
+
+        with col2:
+            feedback = st.text_area("Edit/Submit feedback if not approved:", value=self.feedback, height=700)
+            submit_feedback = st.form_submit_button("✏️ Submit Feedback")
+
+    if approve:
+        self.graph.invoke(Command(resume=""), config=st.session_state.thread)
+        if self.index < len(self.sdlc_nodes) - 1:
+            st.session_state.curr_state = self.sdlc_nodes[self.index + 1]
+            st.session_state.feedback_text = ""
+            st.rerun()
+
+    elif submit_feedback and feedback.strip():
+        st.session_state.feedback_text = feedback
+        self.graph.invoke(Command(resume=feedback), config=st.session_state.thread)
+        st.session_state.feedback_text = ""
+        st.rerun()

src/sdlc/ui/streamlitui/display_qa_testing.py

@@ -0,0 +1,21 @@
+import streamlit as st
+import pandas as pd
+
+def display_qa_results(self,response):
+
+    # Display summary
+    st.subheader("🧪 Test Summary")
+    st.write(response['summary'])
+
+    # Display the table in markdown
+    st.subheader("📋 Test Table")
+    st.markdown(response['table'], unsafe_allow_html=True)
+
+    # Optionally show detailed error info (if any)
+    st.subheader("⚠️ Detailed Errors")
+    errors = [item for item in response['details'] if item.get("Status") == "❌ Fail"]
+    if errors:
+        df_errors = pd.DataFrame(errors)
+        st.dataframe(df_errors)
+    else:
+        st.success("No errors found!")

src/sdlc/ui/streamlitui/display_result.py

@@ -0,0 +1,186 @@
+import streamlit as st
+import uuid
+import base64
+from src.sdlc.utils.utils import get_cached_sdlc_nodes, get_cached_graph, display_states
+from src.sdlc.ui.streamlitui.display_code import display_code_files
+from src.sdlc.ui.streamlitui.display_qa_testing import display_qa_results
+from src.sdlc.ui.streamlitui.display_artifacts import display_downloads
+from langgraph.types import Command
+import json
+
+class DisplayResultStreamlit:
+    def __init__(self):  
+        if "graph" not in st.session_state or st.session_state.page == "home":
+            st.session_state.graph = get_cached_graph()  
+        self.graph = st.session_state.graph  # Use cached graph
+        if not self.graph:
+            st.error("Graph is missing! Restart the SDLC process.")
+            return
+        self.user_requirements = st.session_state.user_requirements
+        self.sdlc_nodes = get_cached_sdlc_nodes()
+        if "thread" not in st.session_state:
+            st.session_state.thread = {"configurable": {"thread_id": str(uuid.uuid4())}}
+        if "curr_state" not in st.session_state:
+            st.session_state.curr_state = self.sdlc_nodes[0]  # Start from first stage
+
+        # Initialize breadcrumbs in session state
+        if "breadcrumbs" not in st.session_state:
+            st.session_state.breadcrumbs = []
+        if "feedback_text" not in st.session_state:
+            st.session_state.feedback_text = ""
+
+    def generate_sdlc(self):
+        try:
+            self.index = self.sdlc_nodes.index(st.session_state.curr_state)
+            request_payload = None
+                
+            if self.index == 0:
+                request_payload = {"user_requirements": self.user_requirements}
+
+            response = ""
+
+            for event in self.graph.stream(request_payload, config=st.session_state.thread, stream_mode="values"):
+                response = event.get(st.session_state.curr_state, "")
+                review = event.get("generated_code_review", "")
+                if st.session_state.curr_state == "generated_code" and review:
+                    self.feedback = review
+
+        except KeyError as e:
+            st.error(f"Graph execution error: Missing key {e}")
+            response = None
+        except Exception as e:
+            st.error(f"Graph execution error: {e}")
+
+        return response
+
+    def display_result_on_ui(self):
+        self.curr_state = st.session_state.curr_state  # Get current state
+        response = self.generate_sdlc()  
+
+        # Update breadcrumbs
+        if self.curr_state not in st.session_state.breadcrumbs:
+            st.session_state.breadcrumbs.append(self.curr_state)
+        
+        # Define layout with right-side progress column
+        col_main, col_sidebar = st.columns([3, 1])
+
+        with col_sidebar:
+            st.markdown("### 🔗 SDLC Progress")
+
+            for idx, state in enumerate(self.sdlc_nodes):
+                display_name = state.replace('_', ' ').title()
+
+                if state == self.curr_state:
+                    # ✅ Current node: green border, bold, larger font
+                    st.markdown(
+                        f"""
+                        <div style="
+                            padding: 6px 12px;
+                            margin-bottom: 6px;
+                            border-left: 4px solid #2e7d32;
+                            color: white;
+                            font-size: 15px;
+                            font-weight: bold;">
+                            🔄 {display_name}
+                        </div>
+                        """,
+                        unsafe_allow_html=True
+                    )
+
+                elif state in st.session_state.breadcrumbs:
+                    # ✅ Completed node
+                    st.markdown(
+                        f"""
+                        <div style="
+                            padding: 6px 12px;
+                            margin-bottom: 6px;
+                            color: #ccc;
+                            font-size: 14px;">
+                            ✅ {display_name}
+                        </div>
+                        """,
+                        unsafe_allow_html=True
+                    )
+
+                else:
+                    # ⏳ Upcoming node
+                    st.markdown(
+                        f"""
+                        <div style="
+                            padding: 6px 12px;
+                            margin-bottom: 6px;
+                            color: #888;
+                            font-size: 14px;">
+                            ⏳ {display_name}
+                        </div>
+                        """,
+                        unsafe_allow_html=True
+                    )
+
+
+
+
+        with col_main:
+            # Display the main SDLC phase
+            state = self.curr_state.replace('_', ' ')
+            st.subheader(f"🛠️ **SDLC Phase: {state.title()}**")
+            if self.curr_state=="qa_testing":
+                print(response)
+
+            if response:
+                #with st.expander(f"📜 **{state}**", expanded=True):
+                if self.curr_state == "consolidated_artifacts":
+                    display_downloads(self)
+                elif self.curr_state == "generated_code":
+                    display_code_files(self, response)
+                elif self.curr_state == "qa_testing":
+                    display_qa_results(self,response)
+                else:
+                    st.markdown(response)
+
+                if self.curr_state != "consolidated_artifacts" and self.curr_state != "generated_code":
+                    with st.form(key="feedback_form", clear_on_submit=True):
+                            col1, col2 = st.columns([1, 2])
+                            with col1:
+                                    approve = st.form_submit_button("✅ Approve")
+                            with col2:
+                                if self.curr_state != "qa_testing" and self.curr_state != "deployment" and self.curr_state !="maintanence_and_updates":
+                                    feedback = st.text_area("Provide feedback if not approved", value=st.session_state.feedback_text, key="feedback_input")
+                                    submit_feedback = st.form_submit_button("Submit Feedback")
+                            status=""
+                            if self.curr_state == "qa_testing" or self.curr_state == "deployment" or self.curr_state =="maintanence_and_updates":
+                                submit_feedback=""
+                                feedback=""
+                                if self.curr_state == "qa_testing":
+                                    status=response
+
+
+                            if approve:
+                                try:
+                                    self.graph.invoke(Command(resume=status), config=st.session_state.thread)
+                                    if self.index < len(self.sdlc_nodes) - 1:
+                                        st.session_state.curr_state = self.sdlc_nodes[self.index + 1]
+                                        st.session_state.feedback_text = ""
+                                        st.rerun()
+                                except ValueError:
+                                    st.error("No nodes found!")
+
+                            elif submit_feedback and feedback:
+                                st.session_state.feedback_text = feedback
+                                self.graph.invoke(Command(resume=feedback), config=st.session_state.thread)
+                                if self.curr_state =="monitoring_and_feedback" and self.index < len(self.sdlc_nodes) - 1:
+                                    st.session_state.curr_state = self.sdlc_nodes[self.index + 1]
+                                st.session_state.feedback_text = ""
+                                st.rerun()
+
+                    if self.curr_state=="qa_testing":
+                        #Convert the list to a JSON string
+                        json_str = json.dumps(response['details'])
+                        display_states(self.curr_state, json_str)
+                    elif self.curr_state != "generated_code":
+                        display_states(self.curr_state, response)
+
+                st.session_state.graph = self.graph  
+                st.session_state.feedback_text = ""  # Reset feedback            
+            else:
+                st.error("Error occurred. Please restart the SDLC cycle.")

src/sdlc/ui/streamlitui/loadui.py

@@ -0,0 +1,44 @@
+import streamlit as st
+from src.sdlc.ui.uiconfigfile import Config
+
+#Sidebar with the user controls
+class LoadStreamlitUI:
+    def __init__(self):
+        self.config =  Config() # config
+        self.user_controls = {}
+
+    def initialize_session(self):
+        return {
+        "sdlc": ""
+    }
+
+
+    def load_streamlit_ui(self):
+        st.set_page_config(page_title= "🛠️ " + self.config.get_page_title(), layout="wide")     
+
+        with st.sidebar:
+            # Get options from config
+            llm_options = self.config.get_llm_options()
+
+            # LLM selection
+            self.user_controls["selected_llm"] = st.selectbox("Select LLM", llm_options)
+
+            if self.user_controls["selected_llm"] == 'Groq':
+                # Model selection
+                model_options = self.config.get_groq_model_options()
+                self.user_controls["selected_groq_model"] = st.selectbox("Select Model", model_options)
+                # API key input
+                self.user_controls["GROQ_API_KEY"] = st.session_state["GROQ_API_KEY"] = st.text_input("API Key",
+                                                                                                      type="password")
+            elif self.user_controls["selected_llm"] == 'OpenAI':
+                # Model selection
+                model_options = self.config.get_openai_model_options()
+                self.user_controls["selected_openai_model"] = st.selectbox("Select Model", model_options)
+                # API key input
+                self.user_controls["OPENAI_API_KEY"] = st.session_state["OPENAI_API_KEY"] = st.text_input("API Key",
+                                                                                                      type="password")
+            
+            if "state" not in st.session_state:
+                st.session_state.state = self.initialize_session()
+            
+        return self.user_controls

src/sdlc/ui/uiconfigfile.ini

@@ -0,0 +1,6 @@
+[DEFAULT]
+PAGE_TITLE = SDLC Lifecycle
+LLM_OPTIONS = Groq,OpenAI
+GROQ_MODEL_OPTIONS = meta-llama/llama-4-scout-17b-16e-instruct,qwen-qwq-32b,llama3-70b-8192,llama3-8b-8192,llama-3.3-70b-versatile,gemma2-9b-it
+OPENAI_MODEL_OPTIONS = GPT-4o,GPT-4o-mini,o3-mini
+SDLC_NODES = user_stories,design_documents,generated_code,security_check,test_cases,qa_testing,deployment,monitoring_and_feedback,maintanence_and_updates,consolidated_artifacts

src/sdlc/ui/uiconfigfile.py

@@ -0,0 +1,23 @@
+from configparser import ConfigParser
+
+class Config:
+    def __init__(self,config_file="./src/sdlc/ui/uiconfigfile.ini"):
+        self.config=ConfigParser()
+        self.config.read(config_file)
+
+    def get_llm_options(self):
+        return self.config["DEFAULT"].get("LLM_OPTIONS").split(",")
+    
+    def get_groq_model_options(self):
+        return self.config["DEFAULT"].get("GROQ_MODEL_OPTIONS").split(",")
+    
+    def get_openai_model_options(self):
+        return self.config["DEFAULT"].get("OPENAI_MODEL_OPTIONS").split(",")
+    
+    def get_page_title(self):
+        return self.config["DEFAULT"].get("PAGE_TITLE")
+    
+    def get_sdlc_nodes(self):
+        return self.config["DEFAULT"].get("SDLC_NODES")
+    
+