Update app.py

app.py

@@ -10,11 +10,14 @@ import datetime
 
 # --- Configuration for the Gradio app's internal logic ---
 # Local cache directory (data will be accumulated here first)
-OUTPUT_DIR = "generated" 
-DATA_FILE = os.path.join(OUTPUT_DIR, f"conversations.jsonl")
+OUTPUT_DIR = "generated"
+DATA_FILE = os.path.join(OUTPUT_DIR, "conversations.jsonl")
+COMMUNITY_PROMPTS_FILE = os.path.join(OUTPUT_DIR, "community_prompts.jsonl")
+COMMIT_TEMPLATES_FILE = os.path.join(OUTPUT_DIR, "commits.json") # New: Commit templates file
 
 # Hugging Face Dataset repository to push to
-HF_DATASET_REPO_ID = "kulia-moon/LimeStory-1.0" # This is the target dataset
+HF_DATASET_REPO_ID = "kulia-moon/LimeStory-1.0" # This is the target dataset for conversations
+HF_COMMUNITY_PROMPT_FILE_IN_REPO = "community_prompts.jsonl" # Target file name within the dataset repo for community prompts
 
 # Configure OpenAI client for Pollinations.ai
 client = openai.OpenAI(
@@ -23,7 +26,6 @@ client = openai.OpenAI(
 )
 
 # Define ALL available models from https://text.pollinations.ai/models
-# This list is more comprehensive. Speeds are approximate relative to each other.
 AVAILABLE_MODELS = {
     "openai": {"description": "GPT-4o mini (generally fast, good all-rounder)", "speed": "Fast"},
     "gemini": {"description": "Gemini 2.0 Flash (designed for speed)", "speed": "Very Fast"},
@@ -83,8 +85,8 @@ DEFAULT_INITIAL_PROMPTS = [
 def chat(system, prompt, selected_model_name, seed=None, num_exchanges=5):
     if seed is None:
         seed = random.randint(0, 1000000)
-    random.seed(seed)
-    
+    random.seed(seed) # Set for reproducibility for the whole conversation generation
+
     conversation = [
         {"from": "system", "value": system},
         {"from": "human", "value": prompt}
@@ -93,40 +95,54 @@ def chat(system, prompt, selected_model_name, seed=None, num_exchanges=5):
         {"role": "system", "content": system},
         {"role": "user", "content": prompt}
     ]
-    
+
     try:
-        response = client.chat.completions.create(
+        # Initial AI response
+        ai_response_obj = client.chat.completions.create(
             model=selected_model_name,
             messages=messages,
             max_tokens=150,
             temperature=0.9,
-            seed=seed
+            seed=seed # Use base seed for first AI response
         )
-        gpt_response = response.choices[0].message.content.strip()
-        
-        conversation.append({"from": "gpt", "value": gpt_response})
-        
-        for i in range(num_exchanges - 1): # Loop for subsequent exchanges
+        ai_response_content = ai_response_obj.choices[0].message.content.strip()
+
+        conversation.append({"from": "gpt", "value": ai_response_content})
+        messages.append({"role": "assistant", "content": ai_response_content})
+
+        # Loop for subsequent exchanges
+        for i in range(num_exchanges - 1): # We already did 1 exchange (human initial -> AI response)
+            # AI generates the *human's* follow-up question/statement
             follow_up_prompt_messages = [
-                {"role": "system", "content": f"You are a helpful and engaging assistant. Based on the last response, generate a polite, open-ended, and cute follow-up question or statement to keep a friendly conversation going. Make it relevant to the last message and consistent with a 'cute' and positive tone."},
-                {"role": "assistant", "content": gpt_response},
-                {"role": "user", "content": "Generate a cute and friendly follow-up."}
+                {"role": "system", "content": "You are a helpful and engaging assistant. Based on the last assistant response, generate a polite, open-ended, and cute follow-up question or statement from a user to keep a friendly conversation going. Make it relevant to the last message and consistent with a 'cute' and positive tone."},
+                {"role": "assistant", "content": ai_response_content}, # Use the last AI response as context
+                {"role": "user", "content": "Generate a cute and friendly follow-up question/statement (max 70 words)."}
             ]
-            
-            follow_up_response = client.chat.completions.create(
-                model=selected_model_name,
+
+            human_follow_up_obj = client.chat.completions.create(
+                model=selected_model_name, # Can use the same model
                 messages=follow_up_prompt_messages,
                 max_tokens=70,
                 temperature=0.8,
-                seed=seed + 1000 + i # Vary seed for follow-ups
+                seed=seed + 1000 + i # Vary seed for human follow-up generation
             )
-            follow_up = follow_up_response.choices[0].message.content.strip()
-            
-            conversation.append({"from": "human", "value": follow_up})
-            
-            messages.append({"role": "assistant", "content": gpt_response})
-            messages.append({"role": "user", "content": follow_up})
-            gpt_response = follow_up_response.choices[0].message.content.strip() # Update gpt_response for next turn's context
+            human_follow_up_content = human_follow_up_obj.choices[0].message.content.strip()
+
+            conversation.append({"from": "human", "value": human_follow_up_content})
+            messages.append({"role": "user", "content": human_follow_up_content})
+
+            # AI generates its next response based on the human follow-up
+            ai_response_obj = client.chat.completions.create(
+                model=selected_model_name,
+                messages=messages, # messages now includes the human follow-up
+                max_tokens=150,
+                temperature=0.9,
+                seed=seed + 2000 + i # Vary seed for next AI response
+            )
+            ai_response_content = ai_response_obj.choices[0].message.content.strip()
+
+            conversation.append({"from": "gpt", "value": ai_response_content})
+            messages.append({"role": "assistant", "content": ai_response_content})
 
         return conversation
     except Exception as e:
@@ -136,141 +152,293 @@ def chat(system, prompt, selected_model_name, seed=None, num_exchanges=5):
         return conversation
 
 # --- Hugging Face Push Function (for Dataset) ---
-# This function will attempt to use the HF_TOKEN environment variable automatically.
-def push_to_huggingface_dataset():
+def push_file_to_huggingface_dataset(file_path, path_in_repo, commit_message_prefix):
     api = HfApi()
-    
-    # Check if HF_TOKEN is available (it should be set as a Space Secret)
+
     hf_token = os.environ.get("HF_TOKEN")
     if not hf_token:
         log_message = "Hugging Face token (HF_TOKEN environment variable) not found. Cannot push to Hub."
         print(log_message)
         return log_message
 
+    if not os.path.exists(file_path) or os.stat(file_path).st_size == 0:
+        log_message = f"No data in {file_path} to push to the dataset."
+        print(log_message)
+        return log_message
+
     try:
-        # Use a temporary file for upload to ensure it's fresh
-        temp_data_file = "temp_conversations_to_upload.jsonl"
-        
-        # Read all conversations from DATA_FILE
-        all_conversations = []
-        if os.path.exists(DATA_FILE):
-            with open(DATA_FILE, "r") as f:
-                for line in f:
-                    all_conversations.append(json.loads(line.strip()))
-
-        if not all_conversations:
-            log_message = "No conversations to push to the dataset."
-            print(log_message)
-            return log_message
-
-        # Write data to a temporary file
-        with open(temp_data_file, "w") as f:
-            for conv in all_conversations:
-                f.write(json.dumps(conv) + "\n")
-
-        # Push the temporary file to the dataset repo
         current_time_str = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-        commit_message = f"Update conversations.jsonl from Gradio app on {current_time_str} (An Nhơn, Binh Dinh, Vietnam)"
+        commit_message = f"{commit_message_prefix} on {current_time_str} (An Nhơn, Binh Dinh, Vietnam)"
         api.upload_file(
-            path_or_fileobj=DATA_FILE ,
-            path_in_repo=DATA_FILE, # The target file name within the dataset repo
+            path_or_fileobj=file_path,
+            path_in_repo=path_in_repo,
             repo_id=HF_DATASET_REPO_ID,
-            repo_type="dataset", # Specify repo_type="dataset"
+            repo_type="dataset",
             commit_message=commit_message,
-            token=hf_token # Use the token from environment variable
+            token=hf_token
         )
-        # Clean up temporary file
-        os.remove(temp_data_file)
-
-        log_message = f"Successfully pushed updated conversations.jsonl to dataset {HF_DATASET_REPO_ID}"
+        log_message = f"Successfully pushed {path_in_repo} to dataset {HF_DATASET_REPO_ID}"
         print(log_message)
         return log_message
     except Exception as e:
-        log_message = f"Error pushing to Hugging Face dataset {HF_DATASET_REPO_ID}: {e}"
+        log_message = f"Error pushing {path_in_repo} to Hugging Face dataset {HF_DATASET_REPO_ID}: {e}"
         print(log_message)
-        if os.path.exists(temp_data_file):
-            os.remove(temp_data_file) # Clean up temp file even on error
         return log_message
 
-# --- Gradio Interface Logic ---
-
-def generate_and_display_conversations(num_conversations_input, custom_prompts_input, custom_system_prompt_input):
-    """
-    Function to be called by Gradio to generate and return conversations,
-    and then automatically push to the dataset.
-    """
+# --- Main Generation and Push Function ---
+def generate_and_display_conversations(num_conversations_input, custom_prompts_input, custom_system_prompt_input,
+                                     commit_subject, commit_body, selected_model_name_input): # New: selected_model_name_input
     num_conversations = int(num_conversations_input)
     if num_conversations <= 0:
         return "Please enter a number of conversations greater than zero.", ""
 
     os.makedirs(OUTPUT_DIR, exist_ok=True)
-    
+
+    # --- Load and Clean Existing Conversations ---
     existing_conversations = []
     if os.path.exists(DATA_FILE):
         with open(DATA_FILE, "r") as f:
             for line in f:
-                existing_conversations.append(json.loads(line.strip()))
+                try:
+                    existing_conversations.append(json.loads(line.strip()))
+                except json.JSONDecodeError as e:
+                    print(f"Skipping malformed JSON line in {DATA_FILE}: {line.strip()} - {e}")
+
+    # Deduplicate existing conversations
+    seen_conversations = set()
+    cleaned_existing_conversations = []
+    for conv_entry in existing_conversations:
+        # Use a string representation of the whole entry for deduplication
+        conv_str = json.dumps(conv_entry, sort_keys=True)
+        if conv_str not in seen_conversations:
+            cleaned_existing_conversations.append(conv_entry)
+            seen_conversations.add(conv_str)
+    
+    # Validate and filter existing conversations for completeness (expected length)
+    expected_msg_len = lambda n_exchanges: 1 + 1 + n_exchanges + (n_exchanges - 1) # System + initial human + AI turns + human follow-ups
+    
+    validated_existing_conversations = []
+    initial_cleaned_count = len(cleaned_existing_conversations)
+    for conv_entry in cleaned_existing_conversations:
+        conv_list = conv_entry.get("conversations", [])
+        # Assume num_exchanges was 5 for old conversations if not stored
+        # Or more robustly, infer from length.
+        # Given the fixed num_exchanges=5 for generation, we can check for this.
+        if len(conv_list) == expected_msg_len(5):
+            validated_existing_conversations.append(conv_entry)
+        else:
+            print(f"Skipping incomplete/malformed existing conversation (length {len(conv_list)} != {expected_msg_len(5)}): {conv_entry}")
+
+    all_conversations = list(validated_existing_conversations) # Start with clean existing ones
+
+    generation_log = []
+    current_time_loc = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') + " (An Nhơn, Binh Dinh, Vietnam)"
+    generation_log.append(f"Starting conversation generation at {current_time_loc}")
+    generation_log.append(f"Loaded and cleaned {len(validated_existing_conversations)} existing conversations (initially {initial_cleaned_count} before validation).")
+    generation_log.append(f"Generating {num_conversations} *new* conversations.")
+    
+    model_names_to_use = list(AVAILABLE_MODELS.keys())
+    if selected_model_name_input and selected_model_name_input in model_names_to_use:
+        # If a specific model is selected, only use that one
+        model_selection_info = f"Specific model selected: '{selected_model_name_input}'"
+    else:
+        # If no specific model or invalid model, pick a random one
+        model_selection_info = f"No specific model selected or invalid, picking randomly from: {', '.join(model_names_to_use)}"
+    generation_log.append(model_selection_info)
+
 
     current_prompts = DEFAULT_INITIAL_PROMPTS
     if custom_prompts_input:
-        # Split custom prompts by comma and clean up whitespace
         parsed_custom_prompts = [p.strip() for p in custom_prompts_input.split(',') if p.strip()]
         if parsed_custom_prompts:
             current_prompts = parsed_custom_prompts
 
-    new_conversations = []
-    model_names_to_use = list(AVAILABLE_MODELS.keys())
-
-    generation_log = []
-    current_time_loc = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') + " (An Nhơn, Binh Dinh, Vietnam)"
-    generation_log.append(f"Starting conversation generation at {current_time_loc}")
-    generation_log.append(f"Generating {num_conversations} conversations.")
-    generation_log.append(f"Models to be used: {', '.join(model_names_to_use)}")
+    new_conversations_generated = []
+    expected_conversation_length = expected_msg_len(5) # Always 5 exchanges for new generations
 
     for i in tqdm(range(num_conversations), desc="Generating conversations"):
         seed = random.randint(0, 1000000)
-        
-        # Select system prompt: user's custom prompt if provided, else random from defaults
+
         if custom_system_prompt_input:
             system = custom_system_prompt_input.strip()
         else:
             system = random.choice(role_play_prompts)
-        
+
         random_name = random.choice(DIVERSE_NAMES)
         prompt_template = random.choice(current_prompts)
-        # Ensure that if [NAME] is not in the template, it's not a problem
         prompt = prompt_template.replace("[NAME]", random_name)
 
-        selected_model_name = random.choice(model_names_to_use) # Randomly pick from ALL models
-        
-        generation_log.append(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Generating conv {i+1}/{num_conversations} with '{selected_model_name}' (System: '{system[:50]}...')") # Log first 50 chars of system prompt
-        conversation = chat(system, prompt, selected_model_name, seed=seed, num_exchanges=5)
+        # Determine the model to use for this specific conversation
+        if selected_model_name_input and selected_model_name_input in model_names_to_use:
+            selected_model_for_this_conv = selected_model_name_input
+        else:
+            selected_model_for_this_conv = random.choice(model_names_to_use)
+            
+        generation_log.append(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Generating conv {i+1}/{num_conversations} with '{selected_model_for_this_conv}' (System: '{system[:50]}...')")
         
-        if len(conversation) > 1 and not any(d.get("from") == "error" for d in conversation):
-            new_conversations.append({"model_used": selected_model_name, "conversations": conversation})
-            generation_log.append(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Successfully generated conv {i+1}/{num_conversations}.")
+        conversation = chat(system, prompt, selected_model_for_this_conv, seed=seed, num_exchanges=5)
+
+        if len(conversation) == expected_conversation_length and not any(d.get("from") == "error" for d in conversation):
+            new_conv_entry = {"model_used": selected_model_for_this_conv, "conversations": conversation}
+            # Add to all_conversations and new_conversations_generated only if not a duplicate of what's already *in memory*
+            # This handles duplicates from current batch or newly generated identical to existing
+            new_conv_str = json.dumps(new_conv_entry, sort_keys=True)
+            if new_conv_str not in seen_conversations:
+                all_conversations.append(new_conv_entry)
+                new_conversations_generated.append(new_conv_entry)
+                seen_conversations.add(new_conv_str) # Mark as seen
+                generation_log.append(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Successfully generated and added conv {i+1}/{num_conversations}.")
+            else:
+                generation_log.append(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Skipped conv {i+1}/{num_conversations} as it's a duplicate.")
         else:
-            generation_log.append(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Skipping conv {i+1}/{num_conversations} due to error or no content.")
+            generation_log.append(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Skipping conv {i+1}/{num_conversations} due to error or incorrect length ({len(conversation)} messages, expected {expected_conversation_length}).")
             if conversation and conversation[-1].get("from") == "error":
                 generation_log.append(f"  Error details: {conversation[-1]['value']}")
 
-    all_conversations = existing_conversations + new_conversations
-
-    # Save to JSONL in the /generated folder
+    # Save all (cleaned existing + newly generated unique) conversations to JSONL
     with open(DATA_FILE, "w") as f:
         for conv in all_conversations:
             f.write(json.dumps(conv) + "\n")
-    
-    generation_log.append(f"Saved {len(new_conversations)} new conversations to {DATA_FILE} (total: {len(all_conversations)}).")
-    generation_log.append("Attempting to push to Hugging Face Dataset...")
 
-    # --- Auto-push to Hugging Face Dataset ---
-    push_status = push_to_huggingface_dataset()
+    generation_log.append(f"Saved {len(new_conversations_generated)} *new unique* conversations to {DATA_FILE} (total unique and validated: {len(all_conversations)}).")
+    generation_log.append("Attempting to push main conversations file to Hugging Face Dataset...")
+
+    # --- Auto-push main conversations to Hugging Face Dataset ---
+    # Use the custom commit message
+    commit_message = f"{commit_subject.strip()}\n\n{commit_body.strip()}" if commit_body.strip() else commit_subject.strip()
+    push_status = push_file_to_huggingface_dataset(DATA_FILE, "conversations.jsonl", commit_message)
     generation_log.append(push_status)
     generation_log.append(f"Process complete at {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')} (An Nhơn, Binh Dinh, Vietnam)")
 
     return json.dumps(all_conversations, indent=2), "\n".join(generation_log)
 
+# --- Community Prompts Functions ---
+def load_community_prompts():
+    prompts = []
+    if os.path.exists(COMMUNITY_PROMPTS_FILE):
+        with open(COMMUNITY_PROMPTS_FILE, "r") as f:
+            for line in f:
+                try:
+                    prompts.append(json.loads(line.strip()))
+                except json.JSONDecodeError:
+                    continue # Skip malformed lines
+    return prompts
+
+def save_community_prompt(system_prompt, initial_prompt):
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    
+    # Load existing prompts to deduplicate and append
+    existing_prompts = load_community_prompts()
+    seen_prompts_for_dedup = set()
+    cleaned_existing_prompts = []
+    for p in existing_prompts:
+        p_str = json.dumps(p, sort_keys=True)
+        if p_str not in seen_prompts_for_dedup:
+            cleaned_existing_prompts.append(p)
+            seen_prompts_for_dedup.add(p_str)
+
+    new_prompt_entry = {
+        "system_prompt": system_prompt.strip(),
+        "initial_prompt": initial_prompt.strip(),
+        "timestamp": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S %Z%z')
+    }
+    new_prompt_str = json.dumps(new_prompt_entry, sort_keys=True)
+
+    log_message = []
+    if not system_prompt.strip() or not initial_prompt.strip():
+        log_message.append("System prompt and Initial prompt cannot be empty.")
+    elif new_prompt_str in seen_prompts_for_dedup:
+        log_message.append("This exact prompt pair already exists in the community list.")
+    else:
+        cleaned_existing_prompts.append(new_prompt_entry)
+        with open(COMMUNITY_PROMPTS_FILE, "w") as f:
+            for p in cleaned_existing_prompts:
+                f.write(json.dumps(p) + "\n")
+        log_message.append("Prompt submitted successfully!")
+        
+        # Immediately attempt to push the updated community prompts file
+        push_status = push_file_to_huggingface_dataset(
+            COMMUNITY_PROMPTS_FILE,
+            HF_COMMUNITY_PROMPT_FILE_IN_REPO,
+            "Update community_prompts.jsonl from Gradio app"
+        )
+        log_message.append(push_status)
+    
+    return "\n".join(log_message), json.dumps(cleaned_existing_prompts, indent=2)
+
+# Function to refresh community prompts display
+def refresh_community_prompts_display():
+    prompts = load_community_prompts()
+    return json.dumps(prompts, indent=2)
+
+# --- Commit Templates Functions ---
+def load_commit_templates():
+    if not os.path.exists(COMMIT_TEMPLATES_FILE):
+        # Create default templates if file doesn't exist
+        default_templates = [
+            {"name": "feat: New Feature", "subject": "feat: ", "body": ""},
+            {"name": "fix: Bug Fix", "subject": "fix: ", "body": "Fixes #[issue_number]"},
+            {"name": "docs: Documentation", "subject": "docs: ", "body": ""},
+            {"name": "chore: Maintenance", "subject": "chore: ", "body": ""},
+            {"name": "style: Formatting", "subject": "style: ", "body": ""},
+            {"name": "refactor: Code Refactor", "subject": "refactor: ", "body": ""},
+            {"name": "perf: Performance Improvement", "subject": "perf: ", "body": ""},
+            {"name": "test: Test Update", "subject": "test: ", "body": ""},
+            {"name": "Custom Empty", "subject": "", "body": ""}
+        ]
+        os.makedirs(OUTPUT_DIR, exist_ok=True)
+        with open(COMMIT_TEMPLATES_FILE, "w") as f:
+            json.dump(default_templates, f, indent=2)
+        return default_templates
+    
+    with open(COMMIT_TEMPLATES_FILE, "r") as f:
+        try:
+            return json.load(f)
+        except json.JSONDecodeError:
+            return [] # Return empty list if file is malformed
+
+def get_template_choices():
+    templates = load_commit_templates()
+    return [t["name"] for t in templates]
+
+def update_commit_fields(selected_template_name):
+    templates = load_commit_templates()
+    for template in templates:
+        if template["name"] == selected_template_name:
+            return template["subject"], template["body"]
+    return "", "" # Fallback if not found
+
+def save_custom_commit_template(template_name, subject, body):
+    templates = load_commit_templates()
+    
+    if not template_name.strip():
+        return "Template name cannot be empty!", gr.Dropdown.update(choices=get_template_choices()), gr.JSON.update(value=templates)
+
+    # Check for existing template with the same name
+    found = False
+    for template in templates:
+        if template["name"] == template_name.strip():
+            template["subject"] = subject.strip()
+            template["body"] = body.strip()
+            found = True
+            break
+    
+    if not found:
+        templates.append({
+            "name": template_name.strip(),
+            "subject": subject.strip(),
+            "body": body.strip()
+        })
+    
+    with open(COMMIT_TEMPLATES_FILE, "w") as f:
+        json.dump(templates, f, indent=2)
+    
+    return f"Template '{template_name.strip()}' saved successfully!", gr.Dropdown.update(choices=get_template_choices()), gr.JSON.update(value=templates)
+
+def refresh_commit_display():
+    templates = load_commit_templates()
+    return gr.Dropdown.update(choices=get_template_choices()), json.dumps(templates, indent=2)
+
 # Gradio Interface setup
 with gr.Blocks() as demo:
     gr.Markdown("# Cute AI Conversation Generator 🐾")
@@ -279,45 +447,235 @@ with gr.Blocks() as demo:
         f"Generated data is saved and pushed to the Hugging Face dataset `{HF_DATASET_REPO_ID}`."
     )
 
-    with gr.Row():
-        num_conversations_input = gr.Slider(minimum=1, maximum=20, value=3, step=1, label="Number of Conversations to Generate", info="More conversations take longer and might hit API limits.")
-        
-    custom_system_prompt_input = gr.Textbox(
-        label="Custom System Prompt (optional)",
-        placeholder="e.g., You are a helpful and kind AI assistant.",
-        info="Define the AI's role or personality. If left empty, a random cute role-play prompt will be used.",
-        lines=3
-    )
+    with gr.Tabs():
+        with gr.Tab("Generate Conversations"):
+            with gr.Row():
+                num_conversations_input = gr.Slider(minimum=1, maximum=20, value=3, step=1, label="Number of Conversations to Generate", info="More conversations take longer and might hit API limits.")
 
-    custom_prompts_input = gr.Textbox(
-        label="Custom Initial Prompts (optional)",
-        placeholder="e.g., What's your favorite color?, Tell me a joke, What makes you happy?",
-        info="Enter multiple prompts separated by commas. If left empty, default prompts will be used. Make sure to include '[NAME]' if you want a name inserted.",
-        lines=3
-    )
+            gr.Markdown("### Model Selection")
+            model_choices_with_descriptions = [
+                f"{name} ({info['description']}, Speed: {info['speed']})"
+                for name, info in AVAILABLE_MODELS.items()
+            ]
+            model_selector_dropdown = gr.Dropdown(
+                label="Select Model (or leave empty for random)",
+                choices=list(AVAILABLE_MODELS.keys()), # The actual values passed will be model names
+                value=None, # Default to no selection, implying random
+                interactive=True,
+                info="Choose a specific model or let the app pick one randomly for each conversation."
+            )
+            # Add a Textbox for model description based on selection
+            model_description_output = gr.Textbox(
+                label="Selected Model Info",
+                interactive=False,
+                lines=2
+            )
+            def get_model_info(model_name):
+                if model_name and model_name in AVAILABLE_MODELS:
+                    info = AVAILABLE_MODELS[model_name]
+                    return f"Description: {info['description']}\nSpeed: {info['speed']}"
+                return "No model selected, or model not found. A random model will be chosen per conversation."
+
+            model_selector_dropdown.change(
+                fn=get_model_info,
+                inputs=model_selector_dropdown,
+                outputs=model_description_output
+            )
+
+
+            custom_system_prompt_input = gr.Textbox(
+                label="Custom System Prompt (optional)",
+                placeholder="e.g., You are a helpful and kind AI assistant.",
+                info="Define the AI's role or personality. If left empty, a random cute role-play prompt will be used.",
+                lines=3
+            )
+
+            custom_prompts_input = gr.Textbox(
+                label="Custom Initial Prompts (optional)",
+                placeholder="e.g., What's your favorite color?, Tell me a joke, What makes you happy?",
+                info="Enter multiple prompts separated by commas. If left empty, default prompts will be used. Make sure to include '[NAME]' if you want a name inserted.",
+                lines=3
+            )
+
+            gr.Markdown("### Hugging Face Commit Message")
+            with gr.Row():
+                commit_template_dropdown = gr.Dropdown(
+                    label="Select Commit Message Template",
+                    choices=get_template_choices(),
+                    value=get_template_choices()[0] if get_template_choices() else None,
+                    interactive=True
+                )
+                refresh_commit_templates_button = gr.Button("Refresh Templates")
+            
+            commit_subject_input = gr.Textbox(
+                label="Commit Subject (max 50 chars)",
+                placeholder="e.g., feat: Add conversation generation feature",
+                lines=1,
+                max_lines=1
+            )
+            commit_body_input = gr.Textbox(
+                label="Commit Body (optional)",
+                placeholder="Detailed description of changes. Use imperative mood.",
+                lines=5
+            )
+
+            generate_button = gr.Button("Generate & Push Conversations")
+
+            output_conversations = gr.JSON(label="Generated Conversations (Content of conversations.jsonl)")
+            output_log = gr.Textbox(label="Process Log", interactive=False, lines=10, max_lines=20)
+
+            # Link commit template dropdown to update fields
+            commit_template_dropdown.change(
+                fn=update_commit_fields,
+                inputs=commit_template_dropdown,
+                outputs=[commit_subject_input, commit_body_input]
+            )
+            # Initial load of commit fields based on default/first template
+            demo.load(
+                fn=lambda: update_commit_fields(get_template_choices()[0] if get_template_choices() else None),
+                inputs=None,
+                outputs=[commit_subject_input, commit_body_input]
+            )
+            
+            generate_button.click(
+                fn=generate_and_display_conversations,
+                inputs=[
+                    num_conversations_input, 
+                    custom_prompts_input, 
+                    custom_system_prompt_input,
+                    commit_subject_input, # Pass commit subject
+                    commit_body_input,     # Pass commit body
+                    model_selector_dropdown # Pass selected model name
+                ],
+                outputs=[output_conversations, output_log],
+                show_progress=True
+            )
+
+        with gr.Tab("Community Prompts"):
+            gr.Markdown("## Share Your Favorite Prompts with the Community!")
+            gr.Markdown(
+                "Submit cute and engaging system prompts and initial prompts here. "
+                "These will be added to a shared list for others to see and use."
+            )
+            community_system_prompt_input = gr.Textbox(
+                label="Your System Prompt",
+                placeholder="e.g., You are a tiny, cheerful squirrel, Squeaky, who loves nuts and collecting shiny things.",
+                lines=3,
+                interactive=True
+            )
+            community_initial_prompt_input = gr.Textbox(
+                label="Your Initial Prompt (Use [NAME] for dynamic naming)",
+                placeholder="e.g., Hey [NAME], what's your favorite type of acorn?",
+                lines=2,
+                interactive=True
+            )
+            submit_community_prompt_button = gr.Button("Submit Prompt to Community")
+            community_submit_status = gr.Textbox(label="Submission Status", interactive=False)
+            
+            gr.Markdown("---")
+            gr.Markdown("## Current Community Prompts")
+            refresh_community_prompts_button = gr.Button("Refresh Community Prompts")
+            community_prompts_display = gr.JSON(label="Submitted Community Prompts")
+
+            submit_community_prompt_button.click(
+                fn=save_community_prompt,
+                inputs=[community_system_prompt_input, community_initial_prompt_input],
+                outputs=[community_submit_status, community_prompts_display],
+                show_progress=True
+            )
+            
+            # Initial load and refresh action for community prompts
+            demo.load(refresh_community_prompts_display, inputs=None, outputs=community_prompts_display)
+            refresh_community_prompts_button.click(refresh_community_prompts_display, inputs=None, outputs=community_prompts_display)
+
+        with gr.Tab("Manage Commit Templates"): # New Tab for Commit Templates
+            gr.Markdown("## Manage Your Local Git Commit Message Templates")
+            gr.Markdown(
+                "Select an existing template to edit, or enter a new name to create a new one. "
+                "These templates are saved locally in `generated/commits.json`."
+            )
+            
+            commit_template_edit_dropdown = gr.Dropdown(
+                label="Select Template to Edit/View",
+                choices=get_template_choices(),
+                value=get_template_choices()[0] if get_template_choices() else None,
+                interactive=True
+            )
+            
+            commit_template_name_input = gr.Textbox(
+                label="Template Name (for saving new or editing existing)",
+                placeholder="e.g., feat: Add New Feature Template"
+            )
+            commit_template_subject_input = gr.Textbox(
+                label="Template Subject Line",
+                placeholder="e.g., feat: "
+            )
+            commit_template_body_input = gr.Textbox(
+                label="Template Body (optional)",
+                placeholder="e.g., - Detailed description of the feature\n- Related issue: #XYZ",
+                lines=5
+            )
+            
+            save_template_button = gr.Button("Save/Update Template")
+            template_status_output = gr.Textbox(label="Template Save Status", interactive=False)
+            all_templates_display = gr.JSON(label="All Current Commit Templates")
+
+            # Link dropdown to populate edit fields
+            commit_template_edit_dropdown.change(
+                fn=lambda name: (name, update_commit_fields(name)[0], update_commit_fields(name)[1]),
+                inputs=commit_template_edit_dropdown,
+                outputs=[commit_template_name_input, commit_template_subject_input, commit_template_body_input]
+            )
+
+            # Action to save/update template
+            save_template_button.click(
+                fn=save_custom_commit_template,
+                inputs=[commit_template_name_input, commit_template_subject_input, commit_template_body_input],
+                outputs=[template_status_output, commit_template_edit_dropdown, all_templates_display] # Update dropdown and JSON display
+            )
+
+            # Initial load of template management tab
+            demo.load(
+                fn=lambda: (
+                    get_template_choices()[0] if get_template_choices() else None, # initial dropdown value
+                    get_template_choices()[0] if get_template_choices() else None, # initial name input
+                    update_commit_fields(get_template_choices()[0] if get_template_choices() else None)[0], # initial subject
+                    update_commit_fields(get_template_choices()[0] if get_template_choices() else None)[1],  # initial body
+                    json.dumps(load_commit_templates(), indent=2) # initial JSON display
+                ),
+                inputs=None,
+                outputs=[
+                    commit_template_edit_dropdown,
+                    commit_template_name_input, 
+                    commit_template_subject_input, 
+                    commit_template_body_input, 
+                    all_templates_display
+                ]
+            )
+            
+            # Refresh button for the main commit templates dropdown in 'Generate Conversations' tab
+            refresh_commit_templates_button.click(
+                fn=refresh_commit_display,
+                inputs=None,
+                outputs=[commit_template_dropdown, all_templates_display] # Refresh both dropdowns and the JSON display
+            )
 
-    generate_button = gr.Button("Generate & Push Conversations")
 
-    output_conversations = gr.JSON(label="Generated Conversations (Content of conversations.jsonl)")
-    output_log = gr.Textbox(label="Process Log", interactive=False, lines=10, max_lines=20) # Increased max_lines for more log visibility
-    
-    generate_button.click(
-        fn=generate_and_display_conversations,
-        inputs=[num_conversations_input, custom_prompts_input, custom_system_prompt_input],
-        outputs=[output_conversations, output_log],
-        show_progress=True
-    )
-    
     gr.Markdown("---")
     gr.Markdown(
-        "**Note on Push to Hub:** This Space is configured to automatically push generated data to "
+        "**Note on Push to Hub:** This Space is configured to automatically push generated data and "
+        "community prompts to the Hugging Face dataset "
         f"`{HF_DATASET_REPO_ID}` using a Hugging Face token securely stored as a Space Secret (`HF_TOKEN`). "
         "User tokens are not required."
     )
     current_datetime_vietnam = datetime.datetime.now(datetime.timezone(datetime.timedelta(hours=7))).strftime('%Y-%m-%d %H:%M:%S %Z%z')
-    gr.Markdown(f"Current server time: {current_datetime_vietnam} (Vietnam)")
+    gr.Markdown(f"Current server time: {current_datetime_vietnam} (An Nhơn, Binh Dinh, Vietnam)")
 
 
 # Launch the Gradio app
 if __name__ == "__main__":
+    # Ensure output directory exists and default commit templates exist on startup
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    load_commit_templates() # This will create the file if it doesn't exist with defaults
+
     demo.launch(debug=True, share=False)