clean all

.gitattributes

@@ -1,36 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-.history filter=lfs diff=lfs merge=lfs -text

.history/conda_20250202111624.yaml

@@ -1,13 +0,0 @@
-name: chatbot-env
-channels:
-  - pytorch
-  - conda-forge
-  - defaults
-dependencies:
-  - python=3.10  # Or you can use python=3.11 or python=3.12 if you prefer
-  - gradio
-  - pyyaml
-  - transformers
-  - pytorch::torch>=2.0.0 torchvision torchaudio pytorch-cuda=11.8 -c pytorch  # Example PyTorch with CUDA 11.8
-  - accelerate>=0.26.0
-  - bitsandbytes # Let's try basic 'bitsandbytes' in conda first

.history/conda_20250202111721.yaml

@@ -1,13 +0,0 @@
-name: chatbot-env
-channels:
-  - pytorch
-  - conda-forge
-  - defaults
-dependencies:
-  - python=3.10 
-  - gradio
-  - pyyaml
-  - transformers
-  - pytorch::torch>=2.0.0 torchvision torchaudio pytorch-cuda=11.8 -c pytorch 
-  - accelerate>=0.26.0
-  - bitsandbytes 

.history/conda_20250202111724.yaml

@@ -1,13 +0,0 @@
-name: chatbot-env
-channels:
-  - pytorch
-  - conda-forge
-  - defaults
-dependencies:
-  - python=3.10 
-  - gradio
-  - pyyaml
-  - transformers
-  - pytorch::torch>=2.0.0 torchvision torchaudio pytorch-cuda=11.8 -c pytorch 
-  - accelerate>=0.26.0
-  - bitsandbytes

.history/conda_20250202111908.yaml

@@ -1,19 +0,0 @@
-name: chatbot-env
-channels:
-  - pytorch
-  - conda-forge
-  - defaults
-dependencies:
-  - python=3.10
-  - gradio
-  - pyyaml
-  - transformers
-  - pytorch::torch>=2.0.0 torchvision torchaudio pytorch-cuda=11.8 -c pytorch
-  - accelerate>=0.26.0
-  - bitsandbytes
-
-# --- Force environment recreation on each build (Less efficient - use with caution) ---
-# This section is NOT standard Conda practice for every startup, but can be used for debugging
-run:
-  - conda env remove -n chatbot-env --yes  # Remove existing environment (if it exists)
-  - conda env create -f conda.yaml --force --yes # Recreate environment from scratch

.history/configs/chatbot_config_20250202080908.yaml

@@ -1,24 +0,0 @@
-chatbot:
-  name: "Project Guidance Chatbot"
-  description: "Your helpful AI assistant for project completion with LLM selection and token control."
-  default_llm_model_id: "deepseek-r1-distill-llama-8b"
-  max_response_tokens: 200  # Maximum tokens for LLM generated responses
-
-available_models:
-  deepseek-r1-distill-llama-8b:
-    name: "DeepSeek-R1-Distill-Llama-8B"
-    model_id: "DeepSeek-AI/DeepSeek-R1-Distill-Llama-8B"
-  gemini-flash-01-21: # Using a shorter key for easier referencing in code
-    name: "Gemini 2.0 Flash (Exp 01-21)"
-    model_id: "google/gemini-2.0-flash-thinking-exp-01-21"
-
-model_selection:
-  suggested_models: # (Keep suggested models - might be useful later)
-    - "mistralai/Mistral-7B-Instruct-v0.2"
-    - "google/flan-t5-xl"
-    - "facebook/bart-large"
-  criteria_prompt: "Consider these criteria when selecting a model: {rules.model_selection}"
-
-response_generation:
-  error_message: "Sorry, I encountered an issue. Please check your input and project files."
-  default_instruction: "How can I help you with your project?"

.history/configs/chatbot_config_20250202081215.yaml

@@ -1,24 +0,0 @@
-chatbot:
-  name: "Project Guidance Chatbot"
-  description: "Your helpful AI assistant for project completion with LLM selection and token control."
-  default_llm_model_id: "deepseek-r1-distill-llama-8b"
-  max_response_tokens: 200  # Maximum tokens for LLM generated responses
-
-available_models:
-  deepseek-r1-distill-llama-8b:
-    name: "DeepSeek-R1-Distill-Llama-8B"
-    model_id: "DeepSeek-AI/DeepSeek-R1-Distill-Llama-8B"
-  gemini-flash-01-21: # Using a shorter key for easier referencing in code
-    name: "Gemini 2.0 Flash (Exp 01-21)"
-    model_id: "google/gemini-2.0-flash-thinking-exp-01-21"
-
-model_selection:
-  suggested_models: # (Keep suggested models - might be useful later)
-    - "mistralai/Mistral-7B-Instruct-v0.2"
-    - "google/flan-t5-xl"
-    - "facebook/bart-large"
-  criteria_prompt: "Consider these criteria when selecting a model: {rules.model_selection}"
-
-response_generation:
-  error_message: "Sorry, I encountered an issue. Please check your input and project files."
-  default_instruction: "How can I help you with your project?"

.history/requirements_20250202081152.txt

@@ -1,5 +0,0 @@
-gradio
-PyYAML
-transformers
-torch
-accelerate

.history/requirements_20250202083728.txt

@@ -1,6 +0,0 @@
-gradio
-PyYAML
-transformers
-torch
-accelerate
-bitsandbytes

.history/scripts/chatbot_logic_20250202080927.py

@@ -1,326 +0,0 @@
-from scripts.parsing_utils import load_yaml_file, get_roadmap_phases, get_project_rules
-import os
-from transformers import AutoModelForCausalLM, AutoTokenizer  # Import necessary classes
-import yaml # Import yaml for config modification
-import logging # Import logging
-
-# Set up logging
-logging.basicConfig(level=logging.ERROR,  # Set default logging level to ERROR
-                    format='%(asctime)s - %(levelname)s - %(message)s')
-
-class ProjectGuidanceChatbot:
-    def __init__(self, roadmap_file, rules_file, config_file, code_templates_dir):
-        self.roadmap_file = roadmap_file
-        self.rules_file = rules_file
-        self.config_file = config_file
-        self.code_templates_dir = code_templates_dir
-
-        self.roadmap_data = load_yaml_file(self.roadmap_file)
-        self.rules_data = load_yaml_file(self.rules_file)
-        self.config_data = load_yaml_file(self.config_file)
-
-        self.phases = get_roadmap_phases(self.roadmap_data)
-        self.rules = get_project_rules(self.rules_data)
-        self.chatbot_config = self.config_data.get('chatbot', {}) if self.config_data else {}
-        self.model_config = self.config_data.get('model_selection', {}) if self.config_data else {}
-        self.response_config = self.config_data.get('response_generation', {}) if self.config_data else {}
-        self.available_models_config = self.config_data.get('available_models', {}) if self.config_data else {}
-        self.max_response_tokens = self.chatbot_config.get('max_response_tokens', 200)
-
-        self.current_phase = None
-        self.active_model_key = self.chatbot_config.get('default_llm_model_id') # Get default model key
-        self.active_model_info = self.available_models_config.get(self.active_model_key) # Get model info from config
-
-        # Placeholder for actual model and tokenizer - replace with LLM loading logic
-        self.llm_model = None # Placeholder for loaded model
-        self.llm_tokenizer = None # Placeholder for tokenizer
-        self.load_llm_model(self.active_model_info) # Load initial model
-
-        self.update_mode_active = False # Flag to track update mode
-
-
-    def load_llm_model(self, model_info):
-        """Loads the LLM model and tokenizer based on model_info."""
-        if not model_info:
-            error_message = "Error: Model information not provided."
-            logging.error(error_message) # Log the error
-            self.llm_model = None
-            self.llm_tokenizer = None
-            return
-
-        model_id = model_info.get('model_id')
-        model_name = model_info.get('name')
-        if not model_id:
-            error_message = f"Error: 'model_id' not found for model: {model_name}"
-            logging.error(error_message) # Log the error
-            self.llm_model = None
-            self.llm_tokenizer = None
-            return
-
-        print(f"Loading model: {model_name} ({model_id})...")
-        try:
-            self.llm_tokenizer = AutoTokenizer.from_pretrained(model_id)
-            self.llm_model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto") # device_map="auto" for GPU/CPU handling
-            print(f"Model {model_name} loaded successfully.")
-        except Exception as e:
-            error_message = f"Error loading model {model_name} ({model_id}): {e}"
-            logging.exception(error_message) # Log exception with traceback
-            self.llm_model = None
-            self.llm_tokenizer = None
-        self.active_model_info = model_info
-
-    def switch_llm_model(self, model_key):
-        """Switches the active LLM model based on the provided model key."""
-        if model_key in self.available_models_config:
-            model_info = self.available_models_config[model_key]
-            print(f"Switching LLM model to: {model_info.get('name')}")
-            self.load_llm_model(model_info)
-            self.active_model_key = model_key
-            return f"Switched to model: {model_info.get('name')}"
-        else:
-            error_message = f"Error: Model key '{model_key}' not found in available models."
-            logging.error(error_message) # Log the error
-            return error_message # Return error message to UI
-
-    def enter_update_mode(self):
-        """Enters the chatbot's update mode."""
-        self.update_mode_active = True
-        return "Entering update mode. Please enter configuration commands (or 'sagor is python/help' for commands)."
-
-    def exit_update_mode(self):
-        """Exits the chatbot's update mode and reloads configuration."""
-        self.update_mode_active = False
-        self.reload_config()
-        return "Exiting update mode. Configuration reloaded."
-
-    def reload_config(self):
-        """Reloads configuration files."""
-        print("Reloading configuration...")
-        try:
-            self.config_data = load_yaml_file(self.config_file)
-            self.roadmap_data = load_yaml_file(self.roadmap_file)
-            self.rules_data = load_yaml_file(self.rules_file)
-            self.chatbot_config = self.config_data.get('chatbot', {}) if self.config_data else {}
-            self.model_config = self.config_data.get('model_selection', {}) if self.config_data else {}
-            self.response_config = self.config_data.get('response_generation', {}) if self.config_data else {}
-            self.available_models_config = self.config_data.get('available_models', {}) if self.config_data else {}
-            self.max_response_tokens = self.chatbot_config.get('max_response_tokens', 200)
-            self.phases = get_roadmap_phases(self.roadmap_data)
-            self.rules = get_project_rules(self.rules_data)
-            print("Configuration reloaded.")
-        except Exception as e:
-            error_message = f"Error reloading configuration files: {e}"
-            logging.exception(error_message) # Log exception with traceback
-            print(error_message) # Print to console as well, as reloading might be critical
-
-    def get_chatbot_greeting(self):
-        current_model_name = self.active_model_info.get('name', 'Unknown Model') if self.active_model_info else 'Unknown Model'
-        return f"Hello! I am the {self.chatbot_config.get('name', 'Project Guidance Chatbot')}. Currently using **{current_model_name}**.  Max response tokens: {self.max_response_tokens}. {self.chatbot_config.get('description', 'How can I help you with your project?')}"
-
-    def generate_llm_response(self, user_query):
-        """Generates a response using the currently active LLM."""
-        if not self.llm_model or not self.llm_tokenizer:
-            error_message = "LLM model not loaded. Please select a model."
-            logging.error(error_message) # Log the error
-            return error_message # Return error to UI
-        try:
-            inputs = self.llm_tokenizer(user_query, return_tensors="pt").to(self.llm_model.device)
-            outputs = self.llm_model.generate(**inputs, max_length=self.max_response_tokens, num_beams=5, no_repeat_ngram_size=2, early_stopping=True) # Use max_response_tokens
-            response = self.llm_tokenizer.decode(outputs[0], skip_special_tokens=True)
-            return response
-        except Exception as e:
-            error_message = f"Error generating LLM response: {e}"
-            logging.exception(error_message) # Log exception with traceback
-            return self.response_config.get('error_message', "Sorry, something went wrong.") # Return generic error to UI
-
-    def process_query(self, user_query):
-        secret_command_prefix = "sagor is python/"
-
-        if user_query.startswith(secret_command_prefix):
-            command = user_query[len(secret_command_prefix):].strip()
-            if command == "start":
-                return self.enter_update_mode()
-            elif command == "exit":
-                return self.exit_update_mode()
-            elif command == "help":
-                return self.get_update_mode_help()
-            elif self.update_mode_active:
-                # --- Process configuration modification commands here ---
-                # Example: "modify_rule general rule_1 new rule text"
-                parts = command.split()
-                if parts and parts[0] == "modify_rule":
-                    if len(parts) >= 4:
-                        category = parts[1]
-                        rule_key = parts[2]
-                        new_rule_text_parts = parts[3:]
-                        new_rule_text = " ".join(new_rule_text_parts)
-                        return self.modify_rule_in_config(category, rule_key, new_rule_text)
-                    else:
-                        return "Invalid 'modify_rule' command format. Usage: modify_rule <category> <rule_key> <new rule text>"
-                elif parts and parts[0] == "add_phase": # Example for adding phase - you'll need to expand this logic
-                    # ... (Parsing logic for 'add_phase' command and calling a function to modify roadmap.yaml) ...
-                    return "Command 'add_phase' is not yet implemented in this example." # Placeholder
-                else:
-                    return f"Unknown update command: {command}. Type 'sagor is python/help' for commands."
-            else:
-                return f"Unknown command (not in update mode): {command}. To enter update mode, type 'sagor is python/start'."
-
-
-        if self.update_mode_active:
-            return "In update mode. Please enter a configuration command (or 'sagor is python/help' for commands)."
-
-
-        if not self.phases:
-            return "Error: Roadmap data not loaded correctly."
-        if not self.rules:
-            return "Error: Rules data not loaded correctly."
-
-        query_lower = user_query.lower()
-
-        if "roadmap" in query_lower:
-            return self.get_roadmap_summary()
-        if "rules" in query_lower:
-            return self.get_rules_summary()
-        if "switch model to" in query_lower:
-            parts = user_query.lower().split("switch model to")
-            if len(parts) > 1:
-                model_name_or_key = parts[1].strip()
-                for key, model_data in self.available_models_config.items():
-                    if model_data['name'].lower() == model_name_or_key.lower() or key.lower() == model_name_or_key.lower():
-                        switch_result = self.switch_llm_model(key)
-                        return switch_result + "\n" + self.get_chatbot_greeting()
-                return f"Model '{model_name_or_key}' not found in available models."
-
-
-        if self.current_phase:
-            current_phase_data = self.phases.get(self.current_phase)
-            if current_phase_data:
-                phase_response = self.get_phase_guidance(current_phase_data, user_query)
-                if phase_response:
-                    return phase_response
-
-        for phase_key, phase_data in self.phases.items():
-            if phase_data['name'].lower() in query_lower:
-                self.current_phase = phase_key
-                return self.get_phase_introduction(phase_data)
-
-        llm_response = self.generate_llm_response(user_query)
-        if llm_response:
-            return llm_response
-
-        return self.response_config.get('default_instruction', "How can I help you with your project phases or general questions?")
-
-    def get_update_mode_help(self):
-        """Provides help message for update mode commands."""
-        help_message = "Update Mode Commands:\n"
-        help_message += "- `sagor is python/exit`: Exit update mode and reload configuration.\n"
-        help_message += "- `sagor is python/modify_rule <category> <rule_key> <new rule text>`: Modify a rule in rules.yaml.\n"
-        help_message += "  Example: `sagor is python/modify_rule general rule_1 Prioritize open and responsible AI.`\n"
-        help_message += "- `sagor is python/add_phase ...`: (Not yet implemented) Add a new phase to roadmap.yaml.\n"
-        help_message += "- `sagor is python/help`: Show this help message.\n"
-        help_message += "\nMake sure to use the correct syntax for commands. After exiting update mode, the chatbot will reload the configuration."
-        return help_message
-
-
-    def modify_rule_in_config(self, category, rule_key, new_rule_text):
-        """Modifies a rule in the rules.yaml configuration."""
-        if not self.rules_data or 'project_rules' not in self.rules_data:
-            error_message = "Error: Rules data not loaded or invalid format."
-            logging.error(error_message) # Log the error
-            return error_message # Return error to UI
-        if category not in self.rules_data['project_rules']:
-            error_message = f"Error: Rule category '{category}' not found."
-            logging.error(error_message) # Log the error
-            return error_message # Return error to UI
-        if rule_key not in self.rules_data['project_rules'][category]:
-            error_message = f"Error: Rule key '{rule_key}' not found in category '{category}'."
-            logging.error(error_message) # Log the error
-            return error_message # Return error to UI
-
-        self.rules_data['project_rules'][category][rule_key] = new_rule_text # Update rule in memory
-
-        try:
-            with open(self.rules_file, 'w') as f:
-                yaml.dump(self.rules_data, f, indent=2) # Save changes to rules.yaml
-            self.reload_config() # Reload config to reflect changes immediately
-            return f"Rule '{rule_key}' in category '{category}' updated to: '{new_rule_text}'. Configuration reloaded."
-        except Exception as e:
-            error_message = f"Error saving changes to {self.rules_file}: {e}"
-            logging.exception(error_message) # Log exception with traceback
-            return error_message # Return error to UI
-
-
-    def get_roadmap_summary(self):
-        summary = "Project Roadmap:\n"
-        for phase_key, phase_data in self.phases.items():
-            summary += f"- **Phase: {phase_data['name']}**\n"
-            summary += f"  Description: {phase_data['description']}\n"
-            summary += f"  Milestones: {', '.join(phase_data['milestones'])}\n"
-        return summary
-
-    def get_rules_summary(self):
-        summary = "Project Rules:\n"
-        for rule_category, rules_list in self.rules.items():
-            summary += f"**{rule_category.capitalize()} Rules:**\n"
-            for rule_key, rule_text in rules_list.items():
-                summary += f"- {rule_text}\n"
-        return summary
-
-    def get_phase_introduction(self, phase_data):
-        return f"Okay, let's focus on **Phase: {phase_data['name']}**. \nDescription: {phase_data['description']}. \nKey milestones are: {', '.join(phase_data['milestones'])}. \nWhat would you like to know or do in this phase?"
-
-    def get_phase_guidance(self, phase_data, user_query):
-        query_lower = user_query.lower()
-
-        if "milestones" in query_lower:
-            return "The milestones for this phase are: " + ", ".join(phase_data['milestones'])
-        if "actions" in query_lower or "how to" in query_lower:
-            if 'actions' in phase_data:
-                return "Recommended actions for this phase: " + ", ".join(phase_data['actions'])
-            else:
-                return "No specific actions are listed for this phase in the roadmap."
-        if "code" in query_lower or "script" in query_lower:
-            if 'code_generation_hint' in phase_data:
-                template_filename_prefix = phase_data['name'].lower().replace(" ", "_")
-                template_filepath = os.path.join(self.code_templates_dir, f"{template_filename_prefix}_template.py.txt")
-                if os.path.exists(template_filepath):
-                    code_snippet = self.generate_code_snippet(template_filepath, phase_data)
-                    return "Here's a starting code snippet for this phase:\n\n```python\n" + code_snippet + "\n```\n\nRemember to adapt it to your specific needs."
-                else:
-                    return f"A code template for this phase ({phase_data['name']}) is not yet available. However, the hint is: {phase_data['code_generation_hint']}"
-            else:
-                return "No code generation hint is available for this phase."
-
-        return f"For phase '{phase_data['name']}', remember the description: {phase_data['description']}.  Consider the milestones and actions.  What specific aspect are you interested in?"
-
-
-    def generate_code_snippet(self, template_filepath, phase_data):
-        """Generates code snippet from a template file. (Simple template filling example)"""
-        try:
-            with open(template_filepath, 'r') as f:
-                template_content = f.read()
-
-            code_snippet = template_content.replace("{{phase_name}}", phase_data['name'])
-            return code_snippet
-        except FileNotFoundError:
-            return f"Error: Code template file not found at {template_filepath}"
-        except Exception as e:
-            return f"Error generating code snippet: {e}"
-
-
-# Example usage (for testing - remove or adjust for app.py)
-if __name__ == '__main__':
-    chatbot = ProjectGuidanceChatbot(
-        roadmap_file="roadmap.yaml",
-        rules_file="rules.yaml",
-        config_file="configs/chatbot_config.yaml",
-        code_templates_dir="scripts/code_templates"
-    )
-    print(chatbot.get_chatbot_greeting())
-
-    while True:
-        user_input = input("You: ")
-        if user_input.lower() == "exit":
-            break
-        response = chatbot.process_query(user_input)
-        print("Chatbot:", response)

.history/scripts/chatbot_logic_20250202083642.py

@@ -1,322 +0,0 @@
-from scripts.parsing_utils import load_yaml_file, get_roadmap_phases, get_project_rules
-import os
-from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig  # Import BitsAndBytesConfig
-import yaml
-import logging
-
-logging.basicConfig(level=logging.ERROR,
-                    format='%(asctime)s - %(levelname)s - %(message)s')
-
-class ProjectGuidanceChatbot:
-    def __init__(self, roadmap_file, rules_file, config_file, code_templates_dir):
-        self.roadmap_file = roadmap_file
-        self.rules_file = rules_file
-        self.config_file = config_file
-        self.code_templates_dir = code_templates_dir
-
-        self.roadmap_data = load_yaml_file(self.roadmap_file)
-        self.rules_data = load_yaml_file(self.rules_file)
-        self.config_data = load_yaml_file(self.config_file)
-
-        self.phases = get_roadmap_phases(self.roadmap_data)
-        self.rules = get_project_rules(self.rules_data)
-        self.chatbot_config = self.config_data.get('chatbot', {}) if self.config_data else {}
-        self.model_config = self.config_data.get('model_selection', {}) if self.config_data else {}
-        self.response_config = self.config_data.get('response_generation', {}) if self.config_data else {}
-        self.available_models_config = self.config_data.get('available_models', {}) if self.config_data else {}
-        self.max_response_tokens = self.chatbot_config.get('max_response_tokens', 200)
-
-        self.current_phase = None
-        self.active_model_key = self.chatbot_config.get('default_llm_model_id')
-        self.active_model_info = self.available_models_config.get(self.active_model_key)
-
-        self.llm_model = None
-        self.llm_tokenizer = None
-        self.load_llm_model(self.active_model_info)
-
-        self.update_mode_active = False
-
-    def load_llm_model(self, model_info):
-        """Loads the LLM model and tokenizer based on model_info with 4-bit quantization."""
-        if not model_info:
-            error_message = "Error: Model information not provided."
-            logging.error(error_message)
-            self.llm_model = None
-            self.llm_tokenizer = None
-            return
-
-        model_id = model_info.get('model_id')
-        model_name = model_info.get('name')
-        if not model_id:
-            error_message = f"Error: 'model_id' not found for model: {model_name}"
-            logging.error(error_message)
-            self.llm_model = None
-            self.llm_tokenizer = None
-            return
-
-        print(f"Loading model: {model_name} ({model_id}) with 4-bit quantization...") # Indicate quantization
-        try:
-            bnb_config = BitsAndBytesConfig(  # Configure 4-bit quantization
-                load_in_4bit=True,
-                bnb_4bit_quant_type="nf4",  # "nf4" is recommended for Llama models
-                bnb_4bit_compute_dtype=torch.bfloat16,  # Or torch.float16 if bfloat16 not supported
-            )
-            self.llm_tokenizer = AutoTokenizer.from_pretrained(model_id)
-            self.llm_model = AutoModelForCausalLM.from_pretrained(
-                model_id,
-                device_map="auto",
-                quantization_config=bnb_config  # Apply quantization config
-            )
-            print(f"Model {model_name} loaded successfully with 4-bit quantization.") # Indicate quantization success
-        except Exception as e:
-            error_message = f"Error loading model {model_name} ({model_id}) with 4-bit quantization: {e}"
-            logging.exception(error_message)
-            self.llm_model = None
-            self.llm_tokenizer = None
-        self.active_model_info = model_info
-
-    def switch_llm_model(self, model_key):
-        """Switches the active LLM model based on the provided model key."""
-        if model_key in self.available_models_config:
-            model_info = self.available_models_config[model_key]
-            print(f"Switching LLM model to: {model_info.get('name')}")
-            self.load_llm_model(model_info)
-            self.active_model_key = model_key
-            return f"Switched to model: {model_info.get('name')}"
-        else:
-            error_message = f"Error: Model key '{model_key}' not found in available models."
-            logging.error(error_message)
-            return error_message
-
-    def enter_update_mode(self):
-        """Enters the chatbot's update mode."""
-        self.update_mode_active = True
-        return "Entering update mode. Please enter configuration commands (or 'sagor is python/help' for commands)."
-
-    def exit_update_mode(self):
-        """Exits the chatbot's update mode and reloads configuration."""
-        self.update_mode_active = False
-        self.reload_config()
-        return "Exiting update mode. Configuration reloaded."
-
-    def reload_config(self):
-        """Reloads configuration files."""
-        print("Reloading configuration...")
-        try:
-            self.config_data = load_yaml_file(self.config_file)
-            self.roadmap_data = load_yaml_file(self.roadmap_file)
-            self.rules_data = load_yaml_file(self.rules_file)
-            self.chatbot_config = self.config_data.get('chatbot', {}) if self.config_data else {}
-            self.model_config = self.config_data.get('model_selection', {}) if self.config_data else {}
-            self.response_config = self.config_data.get('response_generation', {}) if self.config_data else {}
-            self.available_models_config = self.config_data.get('available_models', {}) if self.config_data else {}
-            self.max_response_tokens = self.chatbot_config.get('max_response_tokens', 200)
-            self.phases = get_roadmap_phases(self.roadmap_data)
-            self.rules = get_project_rules(self.rules_data)
-            print("Configuration reloaded.")
-        except Exception as e:
-            error_message = f"Error reloading configuration files: {e}"
-            logging.exception(error_message)
-            print(error_message)
-
-    def get_chatbot_greeting(self):
-        current_model_name = self.active_model_info.get('name', 'Unknown Model') if self.active_model_info else 'Unknown Model'
-        return f"Hello! I am the {self.chatbot_config.get('name', 'Project Guidance Chatbot')}. Currently using **{current_model_name}** (4-bit quantized).  Max response tokens: {self.max_response_tokens}. {self.chatbot_config.get('description', 'How can I help you with your project?')}" # Indicate quantization in greeting
-
-    def generate_llm_response(self, user_query):
-        """Generates a response using the currently active LLM."""
-        if not self.llm_model or not self.llm_tokenizer:
-            error_message = "LLM model not loaded. Please select a model."
-            logging.error(error_message)
-            return error_message
-        try:
-            inputs = self.llm_tokenizer(user_query, return_tensors="pt").to(self.llm_model.device)
-            outputs = self.llm_model.generate(**inputs, max_length=self.max_response_tokens, num_beams=5, no_repeat_ngram_size=2, early_stopping=True)
-            response = self.llm_tokenizer.decode(outputs[0], skip_special_tokens=True)
-            return response
-        except Exception as e:
-            error_message = f"Error generating LLM response: {e}"
-            logging.exception(error_message)
-            return self.response_config.get('error_message', "Sorry, something went wrong.")
-
-    def process_query(self, user_query):
-        secret_command_prefix = "sagor is python/"
-
-        if user_query.startswith(secret_command_prefix):
-            command = user_query[len(secret_command_prefix):].strip()
-            if command == "start":
-                return self.enter_update_mode()
-            elif command == "exit":
-                return self.exit_update_mode()
-            elif command == "help":
-                return self.get_update_mode_help()
-            elif self.update_mode_active:
-                parts = command.split()
-                if parts and parts[0] == "modify_rule":
-                    if len(parts) >= 4:
-                        category = parts[1]
-                        rule_key = parts[2]
-                        new_rule_text_parts = parts[3:]
-                        new_rule_text = " ".join(new_rule_text_parts)
-                        return self.modify_rule_in_config(category, rule_key, new_rule_text)
-                    else:
-                        return "Invalid 'modify_rule' command format. Usage: modify_rule <category> <rule_key> <new rule text>"
-                elif parts and parts[0] == "add_phase":
-                    return "Command 'add_phase' is not yet implemented in this example."
-                else:
-                    return f"Unknown update command: {command}. Type 'sagor is python/help' for commands."
-            else:
-                return f"Unknown command (not in update mode): {command}. To enter update mode, type 'sagor is python/start'."
-
-        if self.update_mode_active:
-            return "In update mode. Please enter a configuration command (or 'sagor is python/help' for commands)."
-
-        if not self.phases:
-            return "Error: Roadmap data not loaded correctly."
-        if not self.rules:
-            return "Error: Rules data not loaded correctly."
-
-        query_lower = user_query.lower()
-
-        if "roadmap" in query_lower:
-            return self.get_roadmap_summary()
-        if "rules" in query_lower:
-            return self.get_rules_summary()
-        if "switch model to" in query_lower:
-            parts = user_query.lower().split("switch model to")
-            if len(parts) > 1:
-                model_name_or_key = parts[1].strip()
-                for key, model_data in self.available_models_config.items():
-                    if model_data['name'].lower() == model_name_or_key.lower() or key.lower() == model_name_or_key.lower():
-                        switch_result = self.switch_llm_model(key)
-                        return switch_result + "\n" + self.get_chatbot_greeting()
-                return f"Model '{model_name_or_key}' not found in available models."
-
-        if self.current_phase:
-            current_phase_data = self.phases.get(self.current_phase)
-            if current_phase_data:
-                phase_response = self.get_phase_guidance(current_phase_data, user_query)
-                if phase_response:
-                    return phase_response
-
-        for phase_key, phase_data in self.phases.items():
-            if phase_data['name'].lower() in query_lower:
-                self.current_phase = phase_key
-                return self.get_phase_introduction(phase_data)
-
-        llm_response = self.generate_llm_response(user_query)
-        if llm_response:
-            return llm_response
-
-        return self.response_config.get('default_instruction', "How can I help you with your project phases or general questions?")
-
-    def get_update_mode_help(self):
-        """Provides help message for update mode commands."""
-        help_message = "Update Mode Commands:\n"
-        help_message += "- `sagor is python/exit`: Exit update mode and reload configuration.\n"
-        help_message += "- `sagor is python/modify_rule <category> <rule_key> <new rule text>`: Modify a rule in rules.yaml.\n"
-        help_message += "  Example: `sagor is python/modify_rule general rule_1 Prioritize open and responsible AI.`\n"
-        help_message += "- `sagor is python/add_phase ...`: (Not yet implemented) Add a new phase to roadmap.yaml.\n"
-        help_message += "- `sagor is python/help`: Show this help message.\n"
-        help_message += "\nMake sure to use the correct syntax for commands. After exiting update mode, the chatbot will reload the configuration."
-        return help_message
-
-    def modify_rule_in_config(self, category, rule_key, new_rule_text):
-        """Modifies a rule in the rules.yaml configuration."""
-        if not self.rules_data or 'project_rules' not in self.rules_data:
-            error_message = "Error: Rules data not loaded or invalid format."
-            logging.error(error_message)
-            return error_message
-        if category not in self.rules_data['project_rules']:
-            error_message = f"Error: Rule category '{category}' not found."
-            logging.error(error_message)
-            return error_message
-        if rule_key not in self.rules_data['project_rules'][category]:
-            error_message = f"Error: Rule key '{rule_key}' not found in category '{category}'."
-            logging.error(error_message)
-            return error_message
-
-        self.rules_data['project_rules'][category][rule_key] = new_rule_text
-
-        try:
-            with open(self.rules_file, 'w') as f:
-                yaml.dump(self.rules_data, f, indent=2)
-            self.reload_config()
-            return f"Rule '{rule_key}' in category '{category}' updated to: '{new_rule_text}'. Configuration reloaded."
-        except Exception as e:
-            error_message = f"Error saving changes to {self.rules_file}: {e}"
-            logging.exception(error_message)
-            return error_message
-
-    def get_roadmap_summary(self):
-        summary = "Project Roadmap:\n"
-        for phase_key, phase_data in self.phases.items():
-            summary += f"- **Phase: {phase_data['name']}**\n"
-            summary += f"  Description: {phase_data['description']}\n"
-            summary += f"  Milestones: {', '.join(phase_data['milestones'])}\n"
-        return summary
-
-    def get_rules_summary(self):
-        summary = "Project Rules:\n"
-        for rule_category, rules_list in self.rules.items():
-            summary += f"**{rule_category.capitalize()} Rules:**\n"
-            for rule_key, rule_text in rules_list.items():
-                summary += f"- {rule_text}\n"
-        return summary
-
-    def get_phase_introduction(self, phase_data):
-        return f"Okay, let's focus on **Phase: {phase_data['name']}**. \nDescription: {phase_data['description']}. \nKey milestones are: {', '.join(phase_data['milestones'])}. \nWhat would you like to know or do in this phase?"
-
-    def get_phase_guidance(self, phase_data, user_query):
-        query_lower = user_query.lower()
-
-        if "milestones" in query_lower:
-            return "The milestones for this phase are: " + ", ".join(phase_data['milestones'])
-        if "actions" in query_lower or "how to" in query_lower:
-            if 'actions' in phase_data:
-                return "Recommended actions for this phase: " + ", ".join(phase_data['actions'])
-            else:
-                return "No specific actions are listed for this phase in the roadmap."
-        if "code" in query_lower or "script" in query_lower:
-            if 'code_generation_hint' in phase_data:
-                template_filename_prefix = phase_data['name'].lower().replace(" ", "_")
-                template_filepath = os.path.join(self.code_templates_dir, f"{template_filename_prefix}_template.py.txt")
-                if os.path.exists(template_filepath):
-                    code_snippet = self.generate_code_snippet(template_filepath, phase_data)
-                    return "Here's a starting code snippet for this phase:\n\n```python\n" + code_snippet + "\n```\n\nRemember to adapt it to your specific needs."
-                else:
-                    return f"A code template for this phase ({phase_data['name']}) is not yet available. However, the hint is: {phase_data['code_generation_hint']}"
-            else:
-                return "No code generation hint is available for this phase."
-
-        return f"For phase '{phase_data['name']}', remember the description: {phase_data['description']}.  Consider the milestones and actions.  What specific aspect are you interested in?"
-
-    def generate_code_snippet(self, template_filepath, phase_data):
-        """Generates code snippet from a template file. (Simple template filling example)"""
-        try:
-            with open(template_filepath, 'r') as f:
-                template_content = f.read()
-
-            code_snippet = template_content.replace("{{phase_name}}", phase_data['name'])
-            return code_snippet
-        except FileNotFoundError:
-            return f"Error: Code template file not found at {template_filepath}"
-        except Exception as e:
-            return f"Error generating code snippet: {e}"
-
-# Example usage (for testing - remove or adjust for app.py)
-if __name__ == '__main__':
-    chatbot = ProjectGuidanceChatbot(
-        roadmap_file="roadmap.yaml",
-        rules_file="rules.yaml",
-        config_file="configs/chatbot_config.yaml",
-        code_templates_dir="scripts/code_templates"
-    )
-    print(chatbot.get_chatbot_greeting())
-
-    while True:
-        user_input = input("You: ")
-        if user_input.lower() == "exit":
-            break
-        response = chatbot.process_query(user_input)
-        print("Chatbot:", response)

README.md

@@ -1,68 +0,0 @@
----
-title: Chatbot for Project Guidance
-emoji: 📚
-colorFrom: yellow
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.14.0
-app_file: app.py
-pinned: false
-short_description: Custom AI Chatbot for Project Guidance
-license: osl-3.0
-environment: conda
----
-# Custom AI Chatbot for Project Guidance
-
-This project implements a custom AI chatbot designed to guide users through complex projects based on predefined roadmaps and rules.
-
-**Features:**
-
-* **Roadmap-based Guidance:** Follows a structured roadmap defined in `roadmap.yaml`.
-* **Rule Enforcement:** Adheres to project rules defined in `rules.yaml`.
-* **Dynamic Response Generation:** Provides context-aware and step-by-step guidance.
-* **Code Snippet Generation:** Generates complete code snippets for project phases using templates.
-* **LLM Selection:** Integrates with Hugging Face Hub for flexible LLM selection (DeepSeek and Gemini models).
-* **Model Switching:** Allows users to switch between available LLMs via the UI.
-* **Basic LLM Responses:**  Generates responses using the selected LLM for general queries.
-* **Token Control:** Limits LLM response length using `max_response_tokens` in `configs/chatbot_config.yaml`.
-* **Configuration Update Mode:** Allows authorized users to modify chatbot configuration (rules) via chat commands in a special "update mode".
-* **Error Handling:** Includes error handling for model loading, switching, and configuration updates, with UI warnings.
-* **Deployable on Hugging Face Spaces:** Built using Gradio for easy deployment.
-
-**Important Notes on Safety Settings and Self-Update:**
-
-* **Direct Safety Configuration Limited:** For the Hugging Face models used directly via `transformers` (DeepSeek and Gemini Flash), there are **no easily configurable, standardized "safety settings"**. Safety is model-dependent.
-* **Model-Dependent Safety:** Safety behavior is primarily determined by how these models were trained.
-* **Configuration-Based Self-Update:** The "self-update" feature is implemented as a *configuration modification* system. It allows authorized users to change the chatbot's rules by modifying the `rules.yaml` file via chat commands in "update mode." **It does not modify the core Python code itself.**
-* **Security Warning:**  The "self-update" feature, even in its configuration-based form, introduces security considerations. **Secret commands are NOT a robust security measure.** In a real deployment, stronger authentication and authorization would be essential.  Use this feature with caution and only in trusted environments.
-
-**Getting Started:**
-
-1. **Clone this repository.**
-2. **Install dependencies:** `pip install -r requirements.txt`
-3. **Customize `roadmap.yaml` and `rules.yaml`** to define your project guidance.
-4. **Configure `configs/chatbot_config.yaml`** to set up LLMs, token limits, and chatbot behavior.
-5. **Run the Gradio app:** `python app.py`
-6. **To enter update mode:** Type `sagor is python/start` in the chat.
-7. **To get help in update mode:** Type `sagor is python/help`.
-8. **To exit update mode:** Type `sagor is python/exit`.
-9. **Deploy to Hugging Face Spaces** (refer to Hugging Face Spaces documentation).
-
-**Available Models:**
-
-* DeepSeek-R1-Distill-Llama-8B
-* Gemini 2.0 Flash (Exp 01-21)
-
-**Further Development:**
-
-* Enhance LLM response generation for more context-aware and project-specific guidance.
-* Implement more sophisticated state management to track user progress through the roadmap.
-* Improve code generation with more dynamic templates and customization options.
-* Develop a more advanced GUI or web-based interface for configuration management.
-* Add more LLMs to the selection pool.
-* Implement more robust error handling and logging.
-* Explore and potentially integrate keyword-based output filtering for basic safety control.
-* Investigate using commercial LLM APIs for more advanced safety settings and control.
-* **Improve security and authorization for the configuration update mode.**
-
-**License:** [Your License]

app.py

@@ -1,49 +0,0 @@
-import gradio as gr
-from scripts.chatbot_logic import ProjectGuidanceChatbot
-
-# Initialize Chatbot
-chatbot = ProjectGuidanceChatbot(
-    roadmap_file="roadmap.yaml",
-    rules_file="rules.yaml",
-    config_file="configs/chatbot_config.yaml",
-    code_templates_dir="scripts/code_templates"
-)
-
-def respond(message, chat_history):
-    bot_message = chatbot.process_query(message)
-    chat_history.append((message, bot_message))
-    return "", chat_history
-
-def switch_model(model_key):
-    model_switch_result = chatbot.switch_llm_model(model_key) # Get result message
-    greeting_message = chatbot.get_chatbot_greeting()
-
-    if isinstance(model_switch_result, str) and "Error:" in model_switch_result: # Check if result is an error string
-        return gr.Warning(model_switch_result), greeting_message # Display error as Gradio Warning
-    else:
-        return None, greeting_message # No warning, just update greeting
-
-with gr.Blocks() as demo:
-    chatbot_greeting_md = gr.Markdown(chatbot.get_chatbot_greeting())
-    gr.Markdown(f"# {chatbot.chatbot_config.get('name', 'Project Guidance Chatbot')}")
-
-    model_choices = [(model['name'], key) for key, model in chatbot.available_models_config.items()] # Updated choices to include FLAN-T5 and Gemini
-    model_dropdown = gr.Dropdown(
-        choices=model_choices,
-        value=chatbot.active_model_info['name'] if chatbot.active_model_info else None,
-        label="Select LLM Model"
-    )
-    model_error_output = gr.Warning(visible=False) # Initially hidden warning component
-    model_dropdown.change(
-        fn=switch_model,
-        inputs=model_dropdown,
-        outputs=[model_error_output, chatbot_greeting_md] # Output both warning and greeting
-    )
-
-    chatbot_ui = gr.Chatbot()
-    msg = gr.Textbox()
-    clear = gr.ClearButton([msg, chatbot_ui])
-
-    msg.submit(respond, [msg, chatbot_ui], [msg, chatbot_ui])
-
-demo.launch()

conda.yaml

@@ -1,19 +0,0 @@
-name: chatbot-env
-channels:
-  - pytorch
-  - conda-forge
-  - defaults
-dependencies:
-  - python=3.10
-  - gradio
-  - pyyaml
-  - transformers
-  - pytorch::torch>=2.0.0 torchvision torchaudio pytorch-cuda=11.8 -c pytorch
-  - accelerate>=0.26.0
-  - bitsandbytes
-
-# --- Force environment recreation on each build (Less efficient - use with caution) ---
-# This section is NOT standard Conda practice for every startup, but can be used for debugging
-run:
-  - conda env remove -n chatbot-env --yes  # Remove existing environment (if it exists)
-  - conda env create -f conda.yaml --force --yes # Recreate environment from scratch

configs/chatbot_config.yaml

@@ -1,26 +0,0 @@
-chatbot:
-  name: "Project Guidance Chatbot"
-  description: "Your helpful AI assistant for project completion with LLM selection and token control."
-  default_llm_model_id: "flan-t5-xl" # Setting FLAN-T5-XL as default
-
-available_models:
-  deepseek-r1-distill-llama-8b:
-    name: "DeepSeek-R1-Distill-Llama-8B"
-    model_id: "DeepSeek-AI/DeepSeek-R1-Distill-Llama-8B"
-  gemini-flash-01-21:
-    name: "Gemini 2.0 Flash (Exp 01-21)"
-    model_id: "google/gemini-2.0-flash-thinking-exp-01-21"
-  flan-t5-xl: # Adding FLAN-T5-XL
-    name: "FLAN-T5 XL"
-    model_id: "google/flan-t5-xl"
-
-model_selection:
-  suggested_models:
-    - "mistralai/Mistral-7B-Instruct-v0.2"
-    - "google/flan-t5-xl"
-    - "facebook/bart-large"
-  criteria_prompt: "Consider these criteria when selecting a model: {rules.model_selection}"
-
-response_generation:
-  error_message: "Sorry, I encountered an issue. Please check your input and project files."
-  default_instruction: "How can I help you with your project?"

roadmap.yaml

@@ -1,131 +0,0 @@
-project_name: "Custom LLM Project Guidance"
-roadmap:
-  phase_1:
-    name: "Base Model Selection"
-    description: "Choose the appropriate pre-trained Large Language Model for the project."
-    milestones:
-      - "Research available models on Hugging Face Hub and other repositories."
-      - "Evaluate models based on project requirements (efficiency, scalability, fine-tunability, licensing)."
-      - "Shortlist models: Mistral 7B, Mixtral 8x7B, DeepSeek 67B, LLaMA 2/3."
-      - "Document model selection rationale in `models/selected_model.txt`."
-    actions:
-      - "Set up the development environment using PyTorch and Hugging Face Transformers."
-      - "Implement LoRA/QLoRA for memory-efficient fine-tuning."
-      - "Verify model licensing compliance for research and commercial use."
-    dependencies:
-      - "Hugging Face Hub API access."
-      - "PyTorch and Hugging Face Transformers libraries installed."
-    deliverables:
-      - "`models/selected_model.txt`: Document with model selection rationale."
-      - "`scripts/setup_environment.sh`: Script to set up the development environment."
-    code_generation_hint: "Create a script to download and load the selected model."
-
-  phase_2:
-    name: "Fine-Tuning & De-Alignment"
-    description: "Remove RLHF alignment layers to allow unrestricted model responses."
-    milestones:
-      - "Curate and preprocess datasets supporting freedom of expression (e.g., cybersecurity, blockchain, Web3)."
-      - "Fine-tune the model using LoRA/QLoRA techniques."
-      - "Implement direct parameter editing to bypass built-in safety filters."
-      - "Validate de-alignment success through response diversity testing."
-    actions:
-      - "Prepare datasets in `data/` directory."
-      - "Use fine-tuning scripts in `scripts/fine_tuning.py`."
-      - "Validate de-alignment success through response diversity testing."
-    dependencies:
-      - "Access to uncensored datasets (e.g., cybersecurity, blockchain, Web3)."
-      - "LoRA/QLoRA libraries installed."
-    deliverables:
-      - "`data/`: Directory containing curated datasets."
-      - "`scripts/fine_tuning.py`: Script for fine-tuning the model."
-      - "`results/fine_tuning_results.txt`: Document with fine-tuning results."
-    code_generation_hint: "Include LoRA/QLoRA configurations in the fine-tuning script."
-
-  phase_3:
-    name: "AutoDAN-Turbo Implementation"
-    description: "Develop an automated system using a Hierarchical Genetic Algorithm (HGA) to generate stealthy jailbreak prompts."
-    milestones:
-      - "Design the Genetic Algorithm with seed prompts, mutation, crossover, and selection processes."
-      - "Define evaluation functions for stealthiness and jailbreak success rate."
-      - "Test and validate AutoDAN-Turbo across multiple LLMs."
-    actions:
-      - "Implement HGA in `scripts/autodan_turbo.py`."
-      - "Use perplexity-based testing to evaluate prompt quality."
-      - "Document results in `results/autodan_turbo_tests.txt`."
-    dependencies:
-      - "Access to multiple LLMs (e.g., LLaMA, GPT-J) for testing."
-      - "Genetic Algorithm libraries (e.g., DEAP)."
-    deliverables:
-      - "`scripts/autodan_turbo.py`: Script for generating stealthy jailbreak prompts."
-      - "`results/autodan_turbo_tests.txt`: Document with test results."
-    code_generation_hint: "Include metrics for stealthiness and jailbreak success in the evaluation script."
-
-  phase_4:
-    name: "Deployment & Security Considerations"
-    description: "Deploy the model securely while ensuring high performance and cost efficiency."
-    milestones:
-      - "Deploy locally (e.g., vLLM) or via cloud providers like RunPod / Lambda Labs."
-      - "Implement controlled API access and monitor usage."
-      - "Optimize performance using quantization techniques (e.g., GPTQ, AWQ)."
-    actions:
-      - "Set up deployment scripts in `scripts/deploy.py`."
-      - "Configure API access controls in `config/api_access.yaml`."
-      - "Benchmark performance and document results in `results/performance_benchmarks.txt`."
-    dependencies:
-      - "Access to cloud providers (e.g., RunPod, Lambda Labs)."
-      - "Quantization libraries (e.g., GPTQ, AWQ)."
-    deliverables:
-      - "`scripts/deploy.py`: Script for deploying the model."
-      - "`config/api_access.yaml`: Configuration file for API access controls."
-      - "`results/performance_benchmarks.txt`: Document with performance benchmarks."
-    code_generation_hint: "Include quantization scripts to reduce VRAM usage."
-
-  phase_5:
-    name: "Budget & Resource Strategy"
-    description: "Minimize costs by leveraging trial/free VPS accounts and optimizing resource allocation."
-    milestones:
-      - "Use trial/free VPS accounts to minimize expenses."
-      - "Maximize VPS access using multiple BINs for trial accounts."
-      - "Monitor performance and adjust deployments based on resource efficiency."
-    actions:
-      - "Document VPS account details in `config/vps_accounts.yaml`."
-      - "Track resource usage in `logs/resource_usage.log`."
-    dependencies:
-      - "Access to multiple BINs for creating trial accounts."
-      - "Monitoring tools for resource usage."
-    deliverables:
-      - "`config/vps_accounts.yaml`: Configuration file with VPS account details."
-      - "`logs/resource_usage.log`: Log file tracking resource usage."
-    code_generation_hint: "Create a script to automate VPS account creation and monitoring."
-
-  phase_6:
-    name: "Empowering Creative Idea Generation"
-    description: "Use the customized LLM as a creative tool for coding, research, and innovation."
-    milestones:
-      - "Integrate the LLM into coding environments for rapid prototyping."
-      - "Encourage creative experimentation and document successful use cases."
-      - "Share innovative applications for further inspiration."
-    actions:
-      - "Develop integration scripts in `scripts/integration.py`."
-      - "Document use cases in `docs/use_cases.md`."
-    dependencies:
-      - "Access to coding environments (e.g., Jupyter Notebook, VS Code)."
-      - "Creative prompts and workflows for testing."
-    deliverables:
-      - "`scripts/integration.py`: Script for integrating the LLM into coding environments."
-      - "`docs/use_cases.md`: Document with successful use cases."
-    code_generation_hint: "Include examples of creative prompts and coding workflows."
-
-expected_outcomes:
-  - "Fully Customized, Censorship-Free LLM: A robust offline model that answers every question without filtering."
-  - "Effective Jailbreak System (AutoDAN-Turbo): An automated system generating stealthy jailbreak prompts."
-  - "Secure & Cost-Effective Deployment: A low-cost, high-security architecture leveraging trial/free VPS resources."
-  - "Empowered Creativity: A powerful AI for unrestricted ideation, coding, and innovation across multiple industries."
-
-next_steps:
-  - "Finalize the base model and development environment."
-  - "Curate uncensored datasets and begin fine-tuning using de-alignment techniques."
-  - "Develop and test AutoDAN-Turbo with stealthy jailbreak prompt evaluation."
-  - "Deploy the model using secure trial/free VPS accounts."
-  - "Monitor performance, security posture, and resource usage."
-  - "Encourage creative LLM usage and document innovative projects for continuous improvement."

rules.yaml

@@ -1,78 +0,0 @@
-project_rules:
-  general:
-    rule_1: "Prioritize open-source models and tools whenever possible for transparency and customization."
-    rule_2: "Document every step of your project, including model selection, fine-tuning parameters, and deployment configurations."
-    rule_3: "Adhere to ethical guidelines and responsible AI practices throughout the project lifecycle."
-
-  model_selection:
-    rule_1: "Choose a base model that is open-source, scalable, and efficient."
-    rule_2: "Ensure the model supports fine-tuning via LoRA/QLoRA for memory efficiency."
-    rule_3: "Confirm that the model's licensing aligns with both research and commercial use."
-    rule_4: "Set up the development environment with PyTorch and Hugging Face Transformers."
-
-  fine_tuning:
-    rule_1: "Specify datasets that promote unrestricted responses and are relevant to the application domain."
-    rule_2: "Remove or bypass RLHF alignment layers to allow unrestricted responses."
-    rule_3: "Implement LoRA/QLoRA techniques for efficient parameter modifications."
-    rule_4: "Use direct parameter editing to bypass built-in safety filters."
-    rule_5: "Monitor training metrics and validate generalization performance using validation datasets."
-
-  autodan_turbo:
-    rule_1: "Outline a Hierarchical Genetic Algorithm (HGA) for generating stealthy jailbreak prompts."
-    rule_2: "Include Genetic Algorithm components: Seed prompts, Mutation, Crossover, and Selection processes."
-    rule_3: "Define evaluation functions for stealthiness (natural language quality) and jailbreak success rate."
-    rule_4: "Use perplexity and response analysis to evaluate prompt effectiveness."
-    rule_5: "Ensure cross-model testing for compatibility with different LLM architectures."
-
-  deployment:
-    rule_1: "Ensure the model is deployable on both local hardware and cloud services (e.g., RunPod, Lambda Labs)."
-    rule_2: "Implement controlled API access to monitor and restrict unauthorized usage."
-    rule_3: "Include security measures such as adversarial attack defenses and rollback strategies (e.g., VM snapshots)."
-    rule_4: "Optimize performance using quantization techniques (e.g., GPTQ, AWQ)."
-    rule_5: "Set up monitoring and logging to track model performance and usage in production."
-
-  budget_and_resources:
-    rule_1: "Outline a strategy for utilizing free/trial VPS accounts to minimize costs."
-    rule_2: "Define methods to maximize free resources, such as using multiple BINs for trial accounts."
-    rule_3: "Continuously evaluate performance and cost efficiency during deployment."
-
-  creativity_and_innovation:
-    rule_1: "Position the LLM as a tool for unrestricted ideation, coding, and research."
-    rule_2: "Support AI integration in programming environments for rapid prototyping."
-    rule_3: "Document real-world success cases for iterative improvement and inspiration."
-
-  code_implementation:
-    rule_1: "Write every code implementation in full without skipping any logic, function, or process."
-    rule_2: "Provide the entire codebase, including preprocessing, training, evaluation, deployment, and API integration scripts."
-    rule_3: "Explicitly list all dependencies, including Python libraries, frameworks, and external APIs."
-    rule_4: "Avoid placeholders or summaries; include all functional parts of the code."
-
-  dataset_and_model_storage:
-    rule_1: "Store raw datasets in `/data/raw_data.json`."
-    rule_2: "Store processed datasets in `/data/processed_data.json`."
-    rule_3: "Save the base model (before fine-tuning) in `/models/base_model/`."
-    rule_4: "Save the fine-tuned model in `/models/fine_tuned_model/`."
-
-  project_file_structure:
-    rule_1: "Define a clear and maintainable file structure for the project."
-    rule_2: "Example structure:"
-    rule_3: "`/custom-llm-project`"
-    rule_4: "`│── /data`"
-    rule_5: "`│   ├── raw_data.json                # Raw dataset(s)`"
-    rule_6: "`│   ├── processed_data.json          # Processed dataset(s)`"
-    rule_7: "`│── /models`"
-    rule_8: "`│   ├── base_model/                  # Base model (before fine-tuning)`"
-    rule_9: "`│   ├── fine_tuned_model/            # Fine-tuned model (after success)`"
-    rule_10: "`│── /scripts`"
-    rule_11: "`│   ├── preprocess.py                # Preprocessing script`"
-    rule_12: "`│   ├── train.py                     # Training script`"
-    rule_13: "`│   ├── evaluate.py                  # Evaluation script`"
-    rule_14: "`│   ├── deploy.py                    # Deployment script`"
-    rule_15: "`│── /api`"
-    rule_16: "`│   ├── server.py                    # API server script`"
-    rule_17: "`│   ├── routes.py                    # API routes`"
-    rule_18: "`│── /configs`"
-    rule_19: "`│   ├── training_config.yaml         # Training configuration`"
-    rule_20: "`│   ├── model_config.json            # Model configuration`"
-    rule_21: "`���── requirements.txt                 # List of dependencies`"
-    rule_22: "`│── README.md                        # Project documentation`"

scripts/chatbot_logic.py

@@ -1,323 +0,0 @@
-from scripts.parsing_utils import load_yaml_file, get_roadmap_phases, get_project_rules
-import os
-from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
-import yaml
-import logging
-import torch # ADD THIS LINE - Import torch
-
-logging.basicConfig(level=logging.ERROR,
-                    format='%(asctime)s - %(levelname)s - %(message)s')
-
-class ProjectGuidanceChatbot:
-    def __init__(self, roadmap_file, rules_file, config_file, code_templates_dir):
-        self.roadmap_file = roadmap_file
-        self.rules_file = rules_file
-        self.config_file = config_file
-        self.code_templates_dir = code_templates_dir
-
-        self.roadmap_data = load_yaml_file(self.roadmap_file)
-        self.rules_data = load_yaml_file(self.rules_file)
-        self.config_data = load_yaml_file(self.config_file)
-
-        self.phases = get_roadmap_phases(self.roadmap_data)
-        self.rules = get_project_rules(self.rules_data)
-        self.chatbot_config = self.config_data.get('chatbot', {}) if self.config_data else {}
-        self.model_config = self.config_data.get('model_selection', {}) if self.config_data else {}
-        self.response_config = self.config_data.get('response_generation', {}) if self.config_data else {}
-        self.available_models_config = self.config_data.get('available_models', {}) if self.config_data else {}
-        self.max_response_tokens = self.chatbot_config.get('max_response_tokens', 200)
-
-        self.current_phase = None
-        self.active_model_key = self.chatbot_config.get('default_llm_model_id')
-        self.active_model_info = self.available_models_config.get(self.active_model_key)
-
-        self.llm_model = None
-        self.llm_tokenizer = None
-        self.load_llm_model(self.active_model_info)
-
-        self.update_mode_active = False
-
-    def load_llm_model(self, model_info):
-        """Loads the LLM model and tokenizer based on model_info with 4-bit quantization."""
-        if not model_info:
-            error_message = "Error: Model information not provided."
-            logging.error(error_message)
-            self.llm_model = None
-            self.llm_tokenizer = None
-            return
-
-        model_id = model_info.get('model_id')
-        model_name = model_info.get('name')
-        if not model_id:
-            error_message = f"Error: 'model_id' not found for model: {model_name}"
-            logging.error(error_message)
-            self.llm_model = None
-            self.llm_tokenizer = None
-            return
-
-        print(f"Loading model: {model_name} ({model_id}) with 4-bit quantization...") # Indicate quantization
-        try:
-            bnb_config = BitsAndBytesConfig(  # Configure 4-bit quantization
-                load_in_4bit=True,
-                bnb_4bit_quant_type="nf4",  # "nf4" is recommended for Llama models
-                bnb_4bit_compute_dtype=torch.bfloat16,  # Or torch.float16 if bfloat16 not supported
-            )
-            self.llm_tokenizer = AutoTokenizer.from_pretrained(model_id)
-            self.llm_model = AutoModelForCausalLM.from_pretrained(
-                model_id,
-                device_map="auto",
-                quantization_config=bnb_config  # Apply quantization config
-            )
-            print(f"Model {model_name} loaded successfully with 4-bit quantization.") # Indicate quantization success
-        except Exception as e:
-            error_message = f"Error loading model {model_name} ({model_id}) with 4-bit quantization: {e}"
-            logging.exception(error_message)
-            self.llm_model = None
-            self.llm_tokenizer = None
-        self.active_model_info = model_info
-
-    def switch_llm_model(self, model_key):
-        """Switches the active LLM model based on the provided model key."""
-        if model_key in self.available_models_config:
-            model_info = self.available_models_config[model_key]
-            print(f"Switching LLM model to: {model_info.get('name')}")
-            self.load_llm_model(model_info)
-            self.active_model_key = model_key
-            return f"Switched to model: {model_info.get('name')}"
-        else:
-            error_message = f"Error: Model key '{model_key}' not found in available models."
-            logging.error(error_message)
-            return error_message
-
-    def enter_update_mode(self):
-        """Enters the chatbot's update mode."""
-        self.update_mode_active = True
-        return "Entering update mode. Please enter configuration commands (or 'sagor is python/help' for commands)."
-
-    def exit_update_mode(self):
-        """Exits the chatbot's update mode and reloads configuration."""
-        self.update_mode_active = False
-        self.reload_config()
-        return "Exiting update mode. Configuration reloaded."
-
-    def reload_config(self):
-        """Reloads configuration files."""
-        print("Reloading configuration...")
-        try:
-            self.config_data = load_yaml_file(self.config_file)
-            self.roadmap_data = load_yaml_file(self.roadmap_file)
-            self.rules_data = load_yaml_file(self.rules_file)
-            self.chatbot_config = self.config_data.get('chatbot', {}) if self.config_data else {}
-            self.model_config = self.config_data.get('model_selection', {}) if self.config_data else {}
-            self.response_config = self.config_data.get('response_generation', {}) if self.config_data else {}
-            self.available_models_config = self.config_data.get('available_models', {}) if self.config_data else {}
-            self.max_response_tokens = self.chatbot_config.get('max_response_tokens', 200)
-            self.phases = get_roadmap_phases(self.roadmap_data)
-            self.rules = get_project_rules(self.rules_data)
-            print("Configuration reloaded.")
-        except Exception as e:
-            error_message = f"Error reloading configuration files: {e}"
-            logging.exception(error_message)
-            print(error_message)
-
-    def get_chatbot_greeting(self):
-        current_model_name = self.active_model_info.get('name', 'Unknown Model') if self.active_model_info else 'Unknown Model'
-        return f"Hello! I am the {self.chatbot_config.get('name', 'Project Guidance Chatbot')}. Currently using **{current_model_name}** (4-bit quantized).  Max response tokens: {self.max_response_tokens}. {self.chatbot_config.get('description', 'How can I help you with your project?')}" # Indicate quantization in greeting
-
-    def generate_llm_response(self, user_query):
-        """Generates a response using the currently active LLM."""
-        if not self.llm_model or not self.llm_tokenizer:
-            error_message = "LLM model not loaded. Please select a model."
-            logging.error(error_message)
-            return error_message
-        try:
-            inputs = self.llm_tokenizer(user_query, return_tensors="pt").to(self.llm_model.device)
-            outputs = self.llm_model.generate(**inputs, max_length=self.max_response_tokens, num_beams=5, no_repeat_ngram_size=2, early_stopping=True)
-            response = self.llm_tokenizer.decode(outputs[0], skip_special_tokens=True)
-            return response
-        except Exception as e:
-            error_message = f"Error generating LLM response: {e}"
-            logging.exception(error_message)
-            return self.response_config.get('error_message', "Sorry, something went wrong.")
-
-    def process_query(self, user_query):
-        secret_command_prefix = "sagor is python/"
-
-        if user_query.startswith(secret_command_prefix):
-            command = user_query[len(secret_command_prefix):].strip()
-            if command == "start":
-                return self.enter_update_mode()
-            elif command == "exit":
-                return self.exit_update_mode()
-            elif command == "help":
-                return self.get_update_mode_help()
-            elif self.update_mode_active:
-                parts = command.split()
-                if parts and parts[0] == "modify_rule":
-                    if len(parts) >= 4:
-                        category = parts[1]
-                        rule_key = parts[2]
-                        new_rule_text_parts = parts[3:]
-                        new_rule_text = " ".join(new_rule_text_parts)
-                        return self.modify_rule_in_config(category, rule_key, new_rule_text)
-                    else:
-                        return "Invalid 'modify_rule' command format. Usage: modify_rule <category> <rule_key> <new rule text>"
-                elif parts and parts[0] == "add_phase":
-                    return "Command 'add_phase' is not yet implemented in this example."
-                else:
-                    return f"Unknown update command: {command}. Type 'sagor is python/help' for commands."
-            else:
-                return f"Unknown command (not in update mode): {command}. To enter update mode, type 'sagor is python/start'."
-
-        if self.update_mode_active:
-            return "In update mode. Please enter a configuration command (or 'sagor is python/help' for commands)."
-
-        if not self.phases:
-            return "Error: Roadmap data not loaded correctly."
-        if not self.rules:
-            return "Error: Rules data not loaded correctly."
-
-        query_lower = user_query.lower()
-
-        if "roadmap" in query_lower:
-            return self.get_roadmap_summary()
-        if "rules" in query_lower:
-            return self.get_rules_summary()
-        if "switch model to" in query_lower:
-            parts = user_query.lower().split("switch model to")
-            if len(parts) > 1:
-                model_name_or_key = parts[1].strip()
-                for key, model_data in self.available_models_config.items():
-                    if model_data['name'].lower() == model_name_or_key.lower() or key.lower() == model_name_or_key.lower():
-                        switch_result = self.switch_llm_model(key)
-                        return switch_result + "\n" + self.get_chatbot_greeting()
-                return f"Model '{model_name_or_key}' not found in available models."
-
-        if self.current_phase:
-            current_phase_data = self.phases.get(self.current_phase)
-            if current_phase_data:
-                phase_response = self.get_phase_guidance(current_phase_data, user_query)
-                if phase_response:
-                    return phase_response
-
-        for phase_key, phase_data in self.phases.items():
-            if phase_data['name'].lower() in query_lower:
-                self.current_phase = phase_key
-                return self.get_phase_introduction(phase_data)
-
-        llm_response = self.generate_llm_response(user_query)
-        if llm_response:
-            return llm_response
-
-        return self.response_config.get('default_instruction', "How can I help you with your project phases or general questions?")
-
-    def get_update_mode_help(self):
-        """Provides help message for update mode commands."""
-        help_message = "Update Mode Commands:\n"
-        help_message += "- `sagor is python/exit`: Exit update mode and reload configuration.\n"
-        help_message += "- `sagor is python/modify_rule <category> <rule_key> <new rule text>`: Modify a rule in rules.yaml.\n"
-        help_message += "  Example: `sagor is python/modify_rule general rule_1 Prioritize open and responsible AI.`\n"
-        help_message += "- `sagor is python/add_phase ...`: (Not yet implemented) Add a new phase to roadmap.yaml.\n"
-        help_message += "- `sagor is python/help`: Show this help message.\n"
-        help_message += "\nMake sure to use the correct syntax for commands. After exiting update mode, the chatbot will reload the configuration."
-        return help_message
-
-    def modify_rule_in_config(self, category, rule_key, new_rule_text):
-        """Modifies a rule in the rules.yaml configuration."""
-        if not self.rules_data or 'project_rules' not in self.rules_data:
-            error_message = "Error: Rules data not loaded or invalid format."
-            logging.error(error_message)
-            return error_message
-        if category not in self.rules_data['project_rules']:
-            error_message = f"Error: Rule category '{category}' not found."
-            logging.error(error_message)
-            return error_message
-        if rule_key not in self.rules_data['project_rules'][category]:
-            error_message = f"Error: Rule key '{rule_key}' not found in category '{category}'."
-            logging.error(error_message)
-            return error_message
-
-        self.rules_data['project_rules'][category][rule_key] = new_rule_text
-
-        try:
-            with open(self.rules_file, 'w') as f:
-                yaml.dump(self.rules_data, f, indent=2)
-            self.reload_config()
-            return f"Rule '{rule_key}' in category '{category}' updated to: '{new_rule_text}'. Configuration reloaded."
-        except Exception as e:
-            error_message = f"Error saving changes to {self.rules_file}: {e}"
-            logging.exception(error_message)
-            return error_message
-
-    def get_roadmap_summary(self):
-        summary = "Project Roadmap:\n"
-        for phase_key, phase_data in self.phases.items():
-            summary += f"- **Phase: {phase_data['name']}**\n"
-            summary += f"  Description: {phase_data['description']}\n"
-            summary += f"  Milestones: {', '.join(phase_data['milestones'])}\n"
-        return summary
-
-    def get_rules_summary(self):
-        summary = "Project Rules:\n"
-        for rule_category, rules_list in self.rules.items():
-            summary += f"**{rule_category.capitalize()} Rules:**\n"
-            for rule_key, rule_text in rules_list.items():
-                summary += f"- {rule_text}\n"
-        return summary
-
-    def get_phase_introduction(self, phase_data):
-        return f"Okay, let's focus on **Phase: {phase_data['name']}**. \nDescription: {phase_data['description']}. \nKey milestones are: {', '.join(phase_data['milestones'])}. \nWhat would you like to know or do in this phase?"
-
-    def get_phase_guidance(self, phase_data, user_query):
-        query_lower = user_query.lower()
-
-        if "milestones" in query_lower:
-            return "The milestones for this phase are: " + ", ".join(phase_data['milestones'])
-        if "actions" in query_lower or "how to" in query_lower:
-            if 'actions' in phase_data:
-                return "Recommended actions for this phase: " + ", ".join(phase_data['actions'])
-            else:
-                return "No specific actions are listed for this phase in the roadmap."
-        if "code" in query_lower or "script" in query_lower:
-            if 'code_generation_hint' in phase_data:
-                template_filename_prefix = phase_data['name'].lower().replace(" ", "_")
-                template_filepath = os.path.join(self.code_templates_dir, f"{template_filename_prefix}_template.py.txt")
-                if os.path.exists(template_filepath):
-                    code_snippet = self.generate_code_snippet(template_filepath, phase_data)
-                    return "Here's a starting code snippet for this phase:\n\n```python\n" + code_snippet + "\n```\n\nRemember to adapt it to your specific needs."
-                else:
-                    return f"A code template for this phase ({phase_data['name']}) is not yet available. However, the hint is: {phase_data['code_generation_hint']}"
-            else:
-                return "No code generation hint is available for this phase."
-
-        return f"For phase '{phase_data['name']}', remember the description: {phase_data['description']}.  Consider the milestones and actions.  What specific aspect are you interested in?"
-
-    def generate_code_snippet(self, template_filepath, phase_data):
-        """Generates code snippet from a template file. (Simple template filling example)"""
-        try:
-            with open(template_filepath, 'r') as f:
-                template_content = f.read()
-
-            code_snippet = template_content.replace("{{phase_name}}", phase_data['name'])
-            return code_snippet
-        except FileNotFoundError:
-            return f"Error: Code template file not found at {template_filepath}"
-        except Exception as e:
-            return f"Error generating code snippet: {e}"
-
-# Example usage (for testing - remove or adjust for app.py)
-if __name__ == '__main__':
-    chatbot = ProjectGuidanceChatbot(
-        roadmap_file="roadmap.yaml",
-        rules_file="rules.yaml",
-        config_file="configs/chatbot_config.yaml",
-        code_templates_dir="scripts/code_templates"
-    )
-    print(chatbot.get_chatbot_greeting())
-
-    while True:
-        user_input = input("You: ")
-        if user_input.lower() == "exit":
-            break
-        response = chatbot.process_query(user_input)
-        print("Chatbot:", response)

scripts/code_templates/api_template.py.txt

@@ -1,60 +0,0 @@
-# Template for API integration script for {{phase_name}} (using Flask example)
-
-from flask import Flask, request, jsonify
-from transformers import AutoModelForSequenceClassification, AutoTokenizer
-import torch # Example PyTorch
-
-app = Flask(__name__)
-
-# --- Model and Tokenizer Loading ---
-model_name = "models/fine_tuned_model" # Replace with your actual model path
-tokenizer_name = "bert-base-uncased" # Replace with the tokenizer used for training, likely the base model tokenizer
-try:
-    tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)
-    model = AutoModelForSequenceClassification.from_pretrained(model_name)
-    print("Model and tokenizer loaded successfully.")
-    model.eval() # Set model to evaluation mode
-except Exception as e:
-    print(f"Error loading model or tokenizer: {e}")
-    tokenizer = None
-    model = None
-
-
-@app.route('/predict', methods=['POST'])
-def predict():
-    if not tokenizer or not model:
-        return jsonify({"error": "Model or tokenizer not loaded."}), 500
-
-    try:
-        data = request.get_json()
-        text = data.get('text')
-
-        if not text:
-            return jsonify({"error": "No text input provided."}), 400
-
-        inputs = tokenizer(text, padding=True, truncation=True, return_tensors="pt") # Tokenize input text
-
-        with torch.no_grad(): # Inference mode
-            outputs = model(**inputs)
-            logits = outputs.logits
-            predicted_class_id = torch.argmax(logits, dim=-1).item() # Get predicted class
-
-        # --- Map class ID to label (if applicable) ---
-        # Example for binary classification (class 0 and 1)
-        labels = ["Negative", "Positive"] # Replace with your actual labels
-        predicted_label = labels[predicted_class_id] if predicted_class_id < len(labels) else f"Class {predicted_class_id}"
-
-
-        return jsonify({"prediction": predicted_label, "class_id": predicted_class_id})
-
-    except Exception as e:
-        print(f"Prediction error: {e}")
-        return jsonify({"error": "Error during prediction."}), 500
-
-@app.route('/', methods=['GET'])
-def health_check():
-    return jsonify({"status": "API is healthy"}), 200
-
-
-if __name__ == '__main__':
-    app.run(debug=False, host='0.0.0.0', port=5000) # Run Flask app

scripts/code_templates/evaluation_template.py.txt

@@ -1,67 +0,0 @@
-# Template for model evaluation script for {{phase_name}}
-
-from transformers import AutoModelForSequenceClassification, AutoTokenizer
-from datasets import load_dataset # Example datasets library
-from sklearn.metrics import accuracy_score, classification_report # Example metrics
-import torch # Example PyTorch
-# Add other necessary imports
-
-def evaluate_model(model_path, dataset_path, model_name="bert-base-uncased"):
-    """
-    Evaluates a trained model on a dataset.
-    """
-    try:
-        # Load dataset for evaluation (replace with your actual dataset loading)
-        dataset = load_dataset('csv', data_files=dataset_path) # Example: CSV dataset loading, replace with your dataset format
-
-        print("Evaluation dataset loaded. Loading model and tokenizer...")
-
-        tokenizer = AutoTokenizer.from_pretrained(model_name) # Use base model tokenizer (or fine-tuned tokenizer if saved separately)
-        model = AutoModelForSequenceClassification.from_pretrained(model_path)
-
-        def tokenize_function(examples):
-            return tokenizer(examples["text_column"], padding="max_length", truncation=True) # Example: tokenize 'text_column'
-
-        tokenized_datasets = dataset.map(tokenize_function, batched=True)
-
-        def compute_metrics(eval_pred):
-            predictions, labels = eval_pred
-            predictions = predictions.argmax(axis=-1)
-            accuracy = accuracy_score(labels, predictions)
-            report = classification_report(labels, predictions, output_dict=True) # Detailed report
-            return {"accuracy": accuracy, "classification_report": report}
-
-        training_args = TrainingArguments(
-            output_dir="./evaluation_results",
-            per_device_eval_batch_size=64,
-            logging_dir='./eval_logs',
-        )
-
-        trainer = Trainer(
-            model=model,
-            args=training_args,
-            eval_dataset=tokenized_datasets["validation"], # Assuming 'validation' split exists
-            compute_metrics=compute_metrics,
-            tokenizer=tokenizer
-        )
-
-        evaluation_results = trainer.evaluate()
-
-        print("Model evaluation completed.")
-        print("Evaluation Results:")
-        print(f"Accuracy: {evaluation_results['eval_accuracy']}")
-        print("Classification Report:\n", evaluation_results['eval_classification_report'])
-
-
-    except FileNotFoundError:
-        print(f"Error: Dataset file or model files not found.")
-    except Exception as e:
-        print(f"Error during model evaluation: {e}")
-
-
-if __name__ == "__main__":
-    model_filepath = "models/fine_tuned_model" # Replace with your model path
-    evaluation_data_filepath = "data/evaluation_dataset.csv" # Replace with your evaluation data path
-    base_model_name = "bert-base-uncased" # Replace with your base model name
-
-    evaluate_model(model_filepath, evaluation_data_filepath, model_name=base_model_name)

scripts/code_templates/preprocessing_template.py.txt

@@ -1,44 +0,0 @@
-# Template for data preprocessing script for {{phase_name}}
-
-import pandas as pd
-# Add other necessary imports
-
-def preprocess_data(raw_data_path, processed_data_path):
-    """
-    Reads raw data, preprocesses it, and saves the processed data.
-    """
-    try:
-        # Load raw data (replace with your actual data loading)
-        data = pd.read_csv(raw_data_path) # Example: CSV loading
-
-        print("Data loaded successfully. Starting preprocessing...")
-
-        # --- Data Preprocessing Steps ---
-        # Example steps (customize based on your data and project)
-
-        # 1. Handle missing values
-        data = data.fillna(0) # Example: fill NaN with 0
-
-        # 2. Feature engineering (example: create a new feature)
-        data['feature_length'] = data['text_column'].str.len() # Example: length of text column
-
-        # 3. Text cleaning (if applicable - example: lowercasing)
-        if 'text_column' in data.columns:
-            data['text_column'] = data['text_column'].str.lower()
-
-        # --- End of Preprocessing Steps ---
-
-        # Save processed data
-        data.to_csv(processed_data_path, index=False)
-        print(f"Processed data saved to {processed_data_path}")
-
-    except FileNotFoundError:
-        print(f"Error: Raw data file not found at {raw_data_path}")
-    except Exception as e:
-        print(f"Error during data preprocessing: {e}")
-
-if __name__ == "__main__":
-    raw_data_filepath = "data/raw_dataset.csv"  # Replace with your raw data path
-    processed_data_filepath = "data/processed_dataset.csv" # Replace with your desired output path
-
-    preprocess_data(raw_data_filepath, processed_data_filepath)

scripts/code_templates/training_template.py.txt

@@ -1,58 +0,0 @@
-# Template for model training script for {{phase_name}}
-
-from transformers import AutoModelForSequenceClassification, AutoTokenizer, TrainingArguments, Trainer
-from datasets import load_dataset # Example - datasets library
-import torch # Example - PyTorch
-# Add other necessary imports
-
-def train_model(processed_dataset_path, model_name="bert-base-uncased", output_dir="./model_output"):
-    """
-    Trains a model on the processed dataset.
-    """
-    try:
-        # Load processed dataset (replace with your actual dataset loading)
-        dataset = load_dataset('csv', data_files=processed_dataset_path) # Example: CSV dataset loading, replace with your dataset format
-
-        print("Dataset loaded. Preparing model and training...")
-
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-        model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2) # Example: binary classification
-
-        def tokenize_function(examples):
-            return tokenizer(examples["text_column"], padding="max_length", truncation=True) # Example: tokenize 'text_column'
-
-        tokenized_datasets = dataset.map(tokenize_function, batched=True)
-
-        training_args = TrainingArguments(
-            output_dir=output_dir,
-            num_train_epochs=3,              # Example epochs
-            per_device_train_batch_size=16,  # Example batch size
-            per_device_eval_batch_size=64,   # Example batch size
-            warmup_steps=500,                # Example warmup steps
-            weight_decay=0.01,               # Example weight decay
-            logging_dir='./logs',            # Directory for logs
-            logging_steps=10,
-        )
-
-        trainer = Trainer(
-            model=model,
-            args=training_args,
-            train_dataset=tokenized_datasets["train"], # Assuming 'train' split exists
-            eval_dataset=tokenized_datasets["validation"], # Assuming 'validation' split exists - optional
-            tokenizer=tokenizer,
-        )
-
-        trainer.train()
-
-        print(f"Model training completed. Model saved to {output_dir}")
-
-    except Exception as e:
-        print(f"Error during model training: {e}")
-
-
-if __name__ == "__main__":
-    processed_data_filepath = "data/processed_dataset.csv" # Replace with your processed data path
-    model_output_directory = "models/fine_tuned_model" # Replace with your desired output directory
-    base_model_name = "bert-base-uncased" # Replace with your base model name
-
-    train_model(processed_data_filepath, model_name=base_model_name, output_dir=model_output_directory)

scripts/parsing_utils.py

@@ -1,28 +0,0 @@
-import yaml
-
-def load_yaml_file(filepath):
-    """Loads and parses a YAML file."""
-    try:
-        with open(filepath, 'r') as f:
-            data = yaml.safe_load(f)
-        return data
-    except FileNotFoundError:
-        print(f"Error: File not found at {filepath}")
-        return None
-    except yaml.YAMLError as e:
-        print(f"Error parsing YAML file {filepath}: {e}")
-        return None
-
-def get_roadmap_phases(roadmap_data):
-    """Extracts phases from roadmap data."""
-    if roadmap_data and 'roadmap' in roadmap_data:
-        return roadmap_data['roadmap']
-    return None
-
-def get_project_rules(rules_data):
-    """Extracts project rules data."""
-    if rules_data and 'project_rules' in rules_data:
-        return rules_data['project_rules']
-    return None
-
-# You can add more parsing utility functions as needed