Undo Functionality & Version Control

Author: DarshanScripts

.env

@@ -5,4 +5,3 @@ EMBEDDING_MODEL="text-embedding-3-small"
 EMBEDDING_API_VERSION="2023-05-15"
 ENDPOINT="https://ai4se-openai.openai.azure.com/"
 AZURE_OPENAI_API_KEY="VDfaCeEbTyAyPRC3C02mZyyANPxZGBxODmWOpWechSlv7GQ8zmmuJQQJ99AKACI8hq2XJ3w3AAABACOGPYeE"
-MONGODB_URI="mongodb://localhost:27017/"

.gitignore

@@ -19,4 +19,5 @@ Thumbs.db
 .env
 
 notes.txt
-temp.json
+temp.json
+user_inputs.txt

README.md

@@ -10,6 +10,7 @@
 -  Classifies input as "General" or "Scenario" intelligently.
 -  Generates detailed scenarios and concise summaries using GPT models.
 -  Converts extracted domain structures into **PlantUML** diagrams.
+-  Stores and manages data using **MongoDB**.
 -  Includes a full test suite for backend routes with **pytest**.
 
 ---
@@ -18,10 +19,11 @@
 
 - **Python 3.9+**
 - **Flask** (Web Framework)
-- **OpenAI API** (Azure variant support)
-- **PlantUML** (Diagram generation)
+- **OpenAI API** (Azure-compatible)
+- **MongoDB** (Database)
+- **PlantUML** (Diagram rendering)
+- **dotenv** (Environment configuration)
 - **pytest** (Testing)
-- **dotenv** (Environment management)
 
 ---
 
@@ -54,10 +56,21 @@ EMBEDDING_MODEL="text-embedding-3-small"
 EMBEDDING_API_VERSION="2023-05-15"
 ENDPOINT="https://your-azure-endpoint/"
 AZURE_OPENAI_API_KEY="your-api-key"
+MONGO_URI="mongodb://localhost:27017/domain_modelling"
 ```
 
 ### 5. Run the application
 ```bash
 python app.py
 ```
 Visit: http://localhost:5000
+
+### MongoDB Setup
+1. Install MongoDB: MongoDB Installation Guide
+
+2. Start MongoDB Server:
+
+```bash
+mongod
+```
+03. Database Connection: The app connects to MongoDB using the URI in .env (MONGO_URI). The database and collections will be created automatically.

src/app.py

@@ -90,6 +90,12 @@ def save_project_data():
     controller = get_project_controller()
     return controller.save_project_data()
 
+@app.route("/undo_project_change", methods=["POST"])
+def undo_project_change():
+    """Undo project change endpoint."""
+    controller = get_project_controller()
+    return controller.undo_project_change()
+
 # Run the application
 if __name__ == "__main__":
     app.run(debug=True)

src/controller/chat_controller.py

@@ -1,83 +1,135 @@
 from flask import request, jsonify, session
 from src.model.llm_service import LLMService
 from src.model.gpt2 import gpt_v2_interface 
+from src.model.project_service import ProjectService
 
 class ChatController:
-    """Controller for chat-related operations"""
+    """Controller for chat-related operations and version saving"""
 
     def __init__(self):
         self.llm_service = LLMService()
+        self.project_service = ProjectService()
 
     def handle_chat_request(self):
-        """Process user input and return domain model with suggestions"""
+        """Process user input and generate response with version saving"""
         try:
-            # Get and validate user input
-            user_input = request.json.get("message", "").strip()
+            data = request.json
+            user_input = data.get("message", "").strip()
+            project_name = data.get("project_name", "").strip()
+
             if not user_input:
                 return jsonify({"error": "User input is required"}), 400
+            if not project_name:
+                return jsonify({"error": "Project name is required to save version"}), 400
+            
+            # Get the current state before processing new input
+            # This ensures we always have the latest domain model and PlantUML
+            project_result, _ = self.project_service.get_project_data(project_name)
+            current_project_data = project_result.get("project_data", {})
+            
+            # Get existing domain model description and PlantUML from project data
+            # These will be used as fallbacks if nothing new is generated
+            existing_dmd = current_project_data.get("domain_model_description", "Welcome to your new project! Start by describing your domain.")
+            existing_plant_uml = current_project_data.get("plant_uml", "@startuml\nskinparam monochrome true\ntitle Your New Project\n\nclass ExampleEntity {\n  +id: string\n  +name: string\n}\n\nnote \"Start building your domain model!\" as N1\n@enduml")
 
-            # Add current input to chat history
             self.llm_service.add_to_chat_history("user", user_input)
-
-            # Get updated chat history after adding the new message
             updated_chat_history = self.llm_service.chat_history.get_messages()
-
-            # Format chat history as a single string
             chat_history_text = "\n".join([
                 f"{'User' if msg['role'] == 'user' else 'Assistant'}: {msg['content']}"
                 for msg in updated_chat_history
             ])
 
-            # Determine input type with enhanced analysis
-            result = self.llm_service.determine_input_type(chat_history_text)
-            
-            # Extract all classification fields
-            decision = result.get("decision", False)
-            is_update = result.get("is_update", False)
-            is_casual_comment = result.get("is_casual_comment", False)
-            suggestions = result.get("suggestions", [])
+            classification_result = self.llm_service.determine_input_type(chat_history_text)
 
-            # Format the response from the suggestions array
-            formatted_suggestions = "\n".join(suggestions) if isinstance(suggestions, list) else suggestions
-            
-            # Handle each case appropriately
+            decision = classification_result.get("decision", False)
+            is_casual_comment = classification_result.get("is_casual_comment", False)
+            suggestions = classification_result.get("suggestions", [])
+            assistant_response = "\n".join(suggestions) if isinstance(suggestions, list) else suggestions
+
+            # Set initial state using existing values to ensure we never store nulls
+            current_dmd = self.llm_service.get_current_domain_model_description() or existing_dmd
+            current_plant_uml = existing_plant_uml
+
             if is_casual_comment:
-                # Casual comment - don't regenerate the domain model
-                self.llm_service.add_to_chat_history("assistant", formatted_suggestions)
+                self.llm_service.add_to_chat_history("assistant", assistant_response)
+                
+                # Use existing domain model and PlantUML (already set above)
+                # If DMD exists but PlantUML doesn't, generate PlantUML
+                if current_dmd and not current_plant_uml:
+                    client = self.llm_service.client
+                    current_plant_uml = gpt_v2_interface(current_dmd, client)
+                
+                self.project_service.save_version(
+                    project_name,
+                    user_input,
+                    assistant_response,
+                    current_dmd,
+                    current_plant_uml
+                )
                 return jsonify({
-                    "response": formatted_suggestions, 
-                    "history": self.llm_service.get_chat_history()
+                    "response": assistant_response,
+                    "history": self.llm_service.get_chat_history(),
+                    "domain_model_description": current_dmd,
+                    "plant_uml": current_plant_uml
                 })
 
-            elif decision:
-                # Enough information for domain modeling (either new model or update)
-                domain_model_description = self.llm_service.generate_domain_model_description(chat_history_text)
+            elif decision: # Enough information for domain modeling (new or update)
+                new_dmd = self.llm_service.generate_domain_model_description(chat_history_text)
+                self.llm_service.add_to_chat_history("assistant", assistant_response)
 
-                # Add response to chat history
-                self.llm_service.add_to_chat_history("assistant", formatted_suggestions)
+                # Generate PlantUML for the new/updated DMD
+                client = self.llm_service.client
+                new_plant_uml = ""
+                if new_dmd:
+                    new_plant_uml = gpt_v2_interface(new_dmd, client)
+                else:
+                    new_dmd = current_dmd  # Fallback to existing DMD
+                    new_plant_uml = current_plant_uml  # Fallback to existing PlantUML
+
+                self.project_service.save_version(
+                    project_name,
+                    user_input,
+                    assistant_response,
+                    new_dmd,
+                    new_plant_uml
+                )
 
                 return jsonify({
-                    "domain_model_description": domain_model_description, 
-                    "suggestion": formatted_suggestions
+                    "domain_model_description": new_dmd, 
+                    "suggestion": assistant_response,
+                    "plant_uml": new_plant_uml
                 })
 
-            else:
-                # Not enough info for domain modeling
-                self.llm_service.add_to_chat_history("assistant", formatted_suggestions)
+            else: # Not enough info for domain modeling
+                self.llm_service.add_to_chat_history("assistant", assistant_response)
+                
+                # Use existing domain model and PlantUML
+                # If we have a domain model but no PlantUML, generate it
+                if current_dmd and not current_plant_uml:
+                    client = self.llm_service.client
+                    current_plant_uml = gpt_v2_interface(current_dmd, client)
+
+                self.project_service.save_version(
+                    project_name,
+                    user_input,
+                    assistant_response,
+                    current_dmd,
+                    current_plant_uml
+                )
 
                 return jsonify({
-                    "response": formatted_suggestions, 
-                    "history": self.llm_service.get_chat_history()
+                    "response": assistant_response, 
+                    "history": self.llm_service.get_chat_history(),
+                    "domain_model_description": current_dmd,
+                    "plant_uml": current_plant_uml
                 })
 
         except Exception as e:
             print(f"Error in chat request: {e}")
             import traceback
-            traceback.print_exc() # Add traceback for better error debugging
+            traceback.print_exc()
             return jsonify({"error": "An unexpected error occurred"}), 500
 
-    # Remove submit_name method
-    
     def generate_uml(self):
         """Generate UML diagram from domain model description"""
         try:

src/controller/project_controller.py

@@ -2,7 +2,7 @@
 from src.model.project_service import ProjectService
 
 class ProjectController:
-    """Controller for project management operations (simplified model)"""
+    """Controller for project management operations"""
 
     def __init__(self):
         self.project_service = ProjectService()
@@ -58,11 +58,38 @@ def save_project_data(self):
             plant_uml = data.get("plant_uml")
             chat_history = data.get("chat_history")
 
-            result, status_code = self.project_service.save_project_data(
-                project_name, domain_model_description, plant_uml, chat_history
+            # Extract last messages from chat history if available
+            user_input = None
+            assistant = None
+            if chat_history and len(chat_history) >= 2:
+                # Assuming the last user message and response are at the end of the chat history
+                for i in range(len(chat_history)-1, -1, -1):
+                    if chat_history[i]["role"] == "assistant" and assistant is None:
+                        assistant = chat_history[i]["content"]
+                    elif chat_history[i]["role"] == "user" and user_input is None:
+                        user_input = chat_history[i]["content"]
+                    if user_input and assistant:
+                        break
+            
+            result, status_code = self.project_service.save_version(
+                project_name, user_input, assistant, domain_model_description, plant_uml
             )
 
             return jsonify(result), status_code
         except Exception as e:
             print(f"Error in save_project_data: {e}")
-            return jsonify({"error": "An unexpected error occurred."}), 500
+            return jsonify({"error": "An unexpected error occurred."}), 500
+
+    def undo_project_change(self):
+        """Handle request to undo the latest version for a project."""
+        try:
+            data = request.json
+            project_name = data.get("project_name", "").strip()
+            if not project_name:
+                return jsonify({"error": "Project name is required."}), 400
+            
+            result, status_code = self.project_service.undo_version(project_name)
+            return jsonify(result), status_code
+        except Exception as e:
+            print(f"Error in undo_project_change controller: {e}")
+            return jsonify({"error": "An unexpected error occurred while undoing version."}), 500