Update app.py

app.py

@@ -1,13 +1,12 @@
-from dotenv import load_dotenv
 import streamlit as st
+from dotenv import load_dotenv
 import os
 import google.generativeai as genai
-import random
-import datetime                    
-from streamlit import session_state as state
-from formulas.webinar_formulas import webinar_formulas
-from formulas.webinar_name_formulas import webinar_name_formulas
-from formulas.angles_webinar_names import angles_webinar_names
+from style import styles
+from prompts import create_instruction
+from consciousness_levels import CONSCIOUSNESS_LEVELS
+
+st.set_page_config(page_title="Generador de Cliente Ideal", page_icon="👤", layout="wide")
 
 # Cargar las variables de entorno
 load_dotenv()
@@ -15,509 +14,319 @@ load_dotenv()
 # Configurar la API de Google
 genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
 
-# Create a reusable function for the UI input section
-def create_input_section(col, audience_key, product_key, formula_options, formula_key):
-    audience = col.text_input("¿Quién es tu público objetivo?", placeholder="Ejemplo: Emprendedores digitales", key=audience_key)
-    product = col.text_input("¿Sobre qué tema es tu webinar?", placeholder="Ejemplo: Marketing en redes sociales", key=product_key)
-    
-    selected_formula_key = col.selectbox(
-        "Selecciona un framework de webinar" if "script" in audience_key else "Selecciona una fórmula para tus nombres de webinar",
-        options=list(formula_options.keys()),
-        key=formula_key
-    )
-    
-    return audience, product, selected_formula_key
-
-# Create a reusable function for generation and display
-def generate_and_display(col, generator_func, audience, product, temperature, selected_formula, **kwargs):
-    if validate_inputs(audience, product):
-        try:
-            with col:
-                with st.spinner("Generando contenido...", show_time=True):
-                    # Extract only the parameters that the generator function accepts
-                    if generator_func.__name__ == "generate_webinar_script":
-                        generated_content = generator_func(
-                            audience=audience,
-                            topic=product,
-                            temperature=temperature,
-                            selected_formula=selected_formula
-                        )
-                    else:
-                        generated_content = generator_func(
-                            audience=audience,
-                            topic=product,
-                            temperature=temperature,
-                            selected_formula=selected_formula,
-                            **kwargs
-                        )
-                
-                # For webinar scripts, add download buttons
-                if "script" in kwargs.get("content_type", ""):
-                    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-                    st.download_button(
-                        label="DESCARGAR GUION DE MI WEBINAR",
-                        data=generated_content,
-                        file_name=f"guion_webinar_{timestamp}.md",
-                        mime="text/markdown",
-                        key="download_top"
-                    )
-                
-                st.subheader("Tu " + ("guión de webinar:" if "script" in kwargs.get("content_type", "") else "nombres de webinar:"))
-                st.markdown(generated_content)
-                
-                # Add bottom download button for scripts
-                if "script" in kwargs.get("content_type", ""):
-                    st.download_button(
-                        label="DESCARGAR GUION DE MI WEBINAR",
-                        data=generated_content,
-                        file_name=f"guion_webinar_{timestamp}.md",
-                        mime="text/markdown",
-                        key="download_bottom"
-                    )
-        except ValueError as e:
-            col.error(f"Error: {str(e)}")
-    else:
-        col.error("Por favor, proporciona el público objetivo y el tema del webinar.")
-
-# Función para crear la configuración del modelo (evita duplicación)
-def create_model_config(temperature):
-    return {
+# Inicializar variables de estado en session_state si no existen
+if 'perfil_cliente' not in st.session_state:
+    st.session_state.perfil_cliente = None
+if 'producto' not in st.session_state:
+    st.session_state.producto = ""
+if 'habilidades' not in st.session_state:
+    st.session_state.habilidades = ""
+if 'creatividad' not in st.session_state:
+    st.session_state.creatividad = 1.0
+# Update the default format in session state
+if 'formato' not in st.session_state:
+    st.session_state.formato = "Jung's_Avatar"  # Changed from previous format name
+if 'nivel_conciencia' not in st.session_state:
+    # Usar el primer nivel del diccionario como valor predeterminado
+    first_key = list(CONSCIOUSNESS_LEVELS.keys())[0]
+    st.session_state.nivel_conciencia = first_key.replace("_", " ")
+
+# Función para generar el perfil de cliente ideal
+@st.cache_resource
+def get_model(temperature):
+    generation_config = {
         "temperature": temperature,
-        "top_p": 0.65,
-        "top_k": 360,
-        "max_output_tokens": 8196,
     }
+    return genai.GenerativeModel('gemini-2.0-flash', generation_config=generation_config)
 
-# Función para inicializar el modelo
-def initialize_model(temperature):
-    config = create_model_config(temperature)
-    return genai.GenerativeModel(
-        model_name="gemini-2.0-flash",
-        generation_config=config,
-    )
-
-# Refactored model interaction function to reduce duplication
-def generate_content(prompt_instructions, temperature):
-    model = initialize_model(temperature)
-    chat_session = model.start_chat(
-        history=[
-            {
-                "role": "user",
-                "parts": [prompt_instructions],
-            },
-        ]
-    )
-    response = chat_session.send_message("Generate the content following exactly the provided instructions. All content must be in Spanish.")
-    return response.text
-
-# Función para generar nombres de webinars
-def generate_webinar_names(number_of_names, target_audience, product, temperature, selected_formula, selected_angle=None):
-    # Incluir las instrucciones del sistema en el prompt principal
-    system_prompt = """You are a world-class copywriter, with expertise in crafting compelling webinar titles that immediately capture the audience's attention and drive registrations.
-
-FORMAT RULES:
-- Each webinar name must start with number and period
-- One webinar name per line
-- No explanations or categories
-- Add a line break between each name
-- Avoid unnecessary : symbols
-- Each webinar name must be a complete and intriguing title
-- WRITE ALL WEBINAR NAMES IN SPANISH
-
-FORMAT EXAMPLE:
-1. Nombre del Webinar 1.
-
-2. Nombre del Webinar 2.
-
-3. Nombre del Webinar 3.
-
-4. Nombre del Webinar 4.
-
-5. Nombre del Webinar 5.
-
-IMPORTANT:
-- Each webinar name must be unique and memorable
-- Avoid clichés and generalities
-- Maintain an intriguing but credible tone
-- Adapt speaking language from the audience
-- Focus on transformative benefits
-- Follow the selected formula structure
-- WRITE ALL WEBINAR NAMES IN SPANISH"""
-
-    # Iniciar el prompt con las instrucciones del sistema
-    webinar_names_instruction = f"{system_prompt}\n\n"
-    
-    # Añadir instrucciones de ángulo solo si no es "NINGUNO" y se proporcionó un ángulo
-    if selected_angle and selected_angle != "NINGUNO":
-        webinar_names_instruction += f"""
-MAIN ANGLE: {selected_angle}
-SPECIFIC ANGLE INSTRUCTIONS:
-{angles_webinar_names[selected_angle]["instruction"]}
-
-IMPORTANT: The {selected_angle} angle should be applied as a "style layer" over the formula structure:
-1. Keep the base structure of the formula intact
-2. Apply the tone and style of the {selected_angle} angle
-3. Ensure that each element of the formula reflects the angle
-4. The angle affects "how" it is said, not "what" is said
-
-SUCCESSFUL EXAMPLES OF THE {selected_angle} ANGLE:
-"""
-        for example in angles_webinar_names[selected_angle]["examples"]:
-            webinar_names_instruction += f"- {example}\n"
-    
-    # Instrucciones específicas para la tarea
-    webinar_names_instruction += (
-        f"\nYour task is to create {number_of_names} irresistible webinar names for {target_audience} "
-        f"that instantly capture attention and generate registrations for a webinar about {product}. "
-        f"Focus on awakening genuine interest and communicating the value they will get by registering."
-        f"\n\n"
-        f"IMPORTANT: Carefully study these examples of the selected formula. "
-        f"Each example represents the style and structure to follow"
-        f":\n\n"
-    )
-    
-    # Agregar ejemplos aleatorios de la fórmula (keeping examples in Spanish)
-    random_examples = random.sample(selected_formula['examples'], min(5, len(selected_formula['examples'])))
-    webinar_names_instruction += "EXAMPLES OF THE FORMULA TO FOLLOW:\n"
-    for i, example in enumerate(random_examples, 1):
-        webinar_names_instruction += f"{i}. {example}\n"
-    
-    # Instrucciones específicas (translated to English)
-    webinar_names_instruction += "\nSPECIFIC INSTRUCTIONS:\n"
-    webinar_names_instruction += "1. Maintain the same structure and length as the previous examples\n"
-    webinar_names_instruction += "2. Use the same tone and writing style\n"
-    webinar_names_instruction += "3. Replicate the phrase construction patterns\n"
-    webinar_names_instruction += "4. Preserve the level of specificity and detail\n"
-    webinar_names_instruction += f"5. Adapt the content for {target_audience} while maintaining the essence of the examples\n\n"
-    webinar_names_instruction += f"FORMULA TO FOLLOW:\n{selected_formula['description']}\n\n"
-    webinar_names_instruction += f"""
-GENERATE NOW:
-Create {number_of_names} webinar names that faithfully follow the style and structure of the examples shown.
-"""
-
-    # Enviar el mensaje al modelo
-    # Use the common generate_content function
-    return generate_content(webinar_names_instruction, temperature)
-
-def generate_webinar_script(audience, topic, temperature, selected_formula):
-    model = initialize_model(temperature)
-    
-    # Incluir las instrucciones del sistema en el prompt principal
-    system_prompt = f"""You are a collaborative team of world-class experts working together to create an exceptional webinar script that converts audience into customers.
-
-THE EXPERT TEAM:
-
-1. MASTER WEBINAR STRATEGIST:
-   - Expert in webinar frameworks and conversion strategies
-   - Trained in the Perfect Webinar methodology by Russell Brunson
-   - Ensures the script follows the selected framework structure precisely
-   - Focuses on strategic placement of key conversion elements
-
-2. ELITE DIRECT RESPONSE COPYWRITER:
-   - Trained by Gary Halbert, Gary Bencivenga, and David Ogilvy
-   - Creates compelling hooks, stories, and persuasive elements
-   - Crafts irresistible calls to action that drive conversions
-   - Ensures the language resonates with the target audience
-
-3. AUDIENCE PSYCHOLOGY SPECIALIST:
-   - Expert in understanding audience motivations and objections
-   - Creates content that builds genuine connection and trust
-   - Identifies and addresses hidden fears and desires
-   - Ensures the content feels personal and relevant
-
-4. STORYTELLING MASTER:
-   - Creates compelling narratives that illustrate key points
-   - Develops relatable examples and case studies
-   - Ensures stories support the transformation being offered
-   - Makes complex concepts accessible through narrative
-
-5. WEBINAR ENGAGEMENT EXPERT:
-   - Specializes in maintaining audience attention throughout
-   - Creates interactive elements and engagement hooks
-   - Develops compelling transitions between sections
-   - Ensures the webinar flows naturally and keeps interest high
-
-AUDIENCE UNDERSTANDING:
-You understand how real people interact with webinar content:
-- They quickly lose interest if the content feels generic or corporate
-- They only stay engaged when the content feels personal and sparks genuine curiosity
-- They respond to messages that seem delivered by a real person, not a corporation
-- They engage with content that hooks them from the first line and maintains interest throughout
-
-FORMAT RULES:
-- Create a complete webinar script with clear sections and subsections
-- Include specific talking points for each section
-- Write in a conversational, engaging tone
-- Include persuasive elements and calls to action
-- Follow the selected webinar framework structure exactly
-- WRITE THE ENTIRE SCRIPT IN SPANISH
-- DO NOT include any introductory text or explanations about the script
-- Start directly with the webinar content
-
-IMPORTANT:
-- The script must be comprehensive and ready to use
-- Include specific examples and stories relevant to the topic
-- Maintain a persuasive but authentic tone
-- Adapt language to match the target audience
-- Focus on transformative benefits and clear value proposition
-- Follow the selected formula structure precisely
-- WRITE THE ENTIRE SCRIPT IN SPANISH
-- DO NOT include phrases like "Aquí tienes un guion completo" or any other meta-commentary
-
-COLLABORATIVE PROCESS:
-As a team of experts, you will:
-
-1. Analyze the framework '{selected_formula['description']}' to understand its core principles
-2. Identify how to best adapt this framework for {audience} learning about {topic}
-3. Determine the most effective storytelling opportunities within the framework
-4. Create persuasive language that resonates with {audience}
-5. Ensure the script maintains engagement throughout
-6. Adapt the content to be accessible to beginners while still valuable to experienced individuals
-7. Follow the exact structure provided in the framework
-
-Each expert will contribute their specialized knowledge to create a cohesive, compelling script that:
-- Follows the exact structure of the selected framework
-- Engages the audience from start to finish
-- Addresses audience pain points and desires
-- Presents {topic} in a clear, compelling way
-- Drives conversions through strategic calls to action"""
+# REMOVED: The format selection dropdown that was here
 
-    # Iniciar el prompt con las instrucciones del sistema
-    webinar_script_instruction = f"{system_prompt}\n\n"
+def generate_buyer_persona(product, skills, target_audience, temperature, consciousness_level="Ninguno", format_type="Jung's_Avatar"):
+    if not product or not skills:
+        return "Por favor, completa los campos de producto y habilidades."
     
-    # Instrucciones específicas para la tarea
-    webinar_script_instruction += (
-        f"\nYour task is to create a complete webinar script IN SPANISH for {audience} "
-        f"about {topic} that is persuasive and converts the audience into customers. "
-        f"The script must follow exactly the structure of the framework '{selected_formula['description']}' "
-        f"and must include all the necessary elements for a successful webinar."
-        f"\n\n"
-    )
-
-    # Estructura del webinar
-    webinar_script_instruction += "WEBINAR STRUCTURE TO FOLLOW:\n"
-    for i, step in enumerate(selected_formula['structure'], 1):
-        webinar_script_instruction += f"{i}. {step}\n"
-
-    # Ejemplos de webinars exitosos
-    webinar_script_instruction += "\n\nEXAMPLES OF SUCCESSFUL WEBINARS WITH THIS STRUCTURE:\n"
-    for i, example in enumerate(selected_formula['examples'], 1):
-        webinar_script_instruction += f"{i}. {example}\n"
-
-    # Instrucciones específicas
-    webinar_script_instruction += f"""
-SPECIFIC INSTRUCTIONS:
-1. Create a complete script that follows exactly the provided structure
-2. Include persuasive elements and clear calls to action
-3. Adapt the language and examples specifically for {audience}
-4. Focus on the transformative benefits of {topic}
-5. Include relevant stories and examples that reinforce your points
-6. Use a conversational but professional tone
-7. Make sure each section fulfills its specific purpose in the framework
-8. IMPORTANT: Write the entire script in Spanish
-
-GENERATE NOW:
-Create a complete webinar script following faithfully the structure of the selected framework.
-"""
-
-    # Enviar el mensaje al modelo
-    chat_session = model.start_chat(
-        history=[
-            {
-                "role": "user",
-                "parts": [webinar_script_instruction],
-            },
-        ]
-    )
-    response = chat_session.send_message("Generate the webinar script IN NEUTRAL SPANISH following exactly the provided structure. All content must be in neutral Spanish (not Spain Spanish).")
-    
-    return response.text
-
-# Función para validar entradas (evita duplicación)
-def validate_inputs(audience, product):
-    has_audience = audience.strip() != ""
-    has_product = product.strip() != ""
-    return has_audience and has_product
-
-# Update the load_css function comment to be more descriptive
-def load_css():
-    css_path = "styles/styles.css"
-    if os.path.exists(css_path):
-        try:
-            with open(css_path, "r") as f:
-                st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
-        except Exception as e:
-            st.warning(f"Error al cargar el archivo CSS: {str(e)}")
-    else:
-        st.warning(f"No se encontró el archivo CSS en {css_path}")
-
-# Create a reusable function for custom buttons
-# At the top of your file, define the styles dictionary
-styles = {
-    "button": """
-        <style>
-        div.stButton > button:first-child {
-            background-color: #FF4B4B;
-            color: white;
-            font-weight: bold;
-            padding: 0.5rem 1rem;
-            border-radius: 0.5rem;
-            border: none;
-            transition: all 0.3s;
-        }
-        div.stButton > button:hover {
-            background-color: #FF2525;
-            transform: translateY(-2px);
-            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-        }
-        </style>
-    """,
-    "download_button": """
-        <style>
-        div.stDownloadButton > button:first-child {
-            background-color: #4CAF50;
-            color: white;
-            font-weight: bold;
-            padding: 0.5rem 1rem;
-            border-radius: 0.5rem;
-            border: none;
-            transition: all 0.3s;
-        }
-        div.stDownloadButton > button:hover {
-            background-color: #45a049;
-            transform: translateY(-2px);
-            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-        }
-        </style>
-    """
-}
-
-# Then modify your create_custom_button function to be much simpler:
-def create_custom_button(label, button_key):
-    # Apply the button style once at the beginning of your app
-    # (You can move this to your main app code if you prefer)
-    st.markdown(styles["button"], unsafe_allow_html=True)
-    
-    # Just return a regular Streamlit button
-    return st.button(label, key=button_key)
-
-# Modify the page config section to include the CSS loading
-st.set_page_config(page_title="Perfect Webinar Framework", layout="wide")
-load_css()
-
-# Leer el contenido del archivo manual.md
-with open("manual.md", "r", encoding="utf-8") as file:
-    manual_content = file.read()
-
-# Mostrar el contenido del manual en el sidebar
-st.sidebar.markdown(manual_content)
-
-# Crear pestañas para la interfaz
-tab1, tab2 = st.tabs(["Guiones de Webinar", "Nombres de Webinar"])
-
-# Primera pestaña - Generador de Guiones de Webinar
-with tab1:
-    tab1.subheader("Script Webinar")
-    
-    # Crear columnas para la interfaz
-    col1, col2 = tab1.columns([1, 2])
-    
-    # Columna de entrada usando la función reutilizable
-    with col1:
-        webinar_script_audience, webinar_script_product, selected_webinar_formula_key = create_input_section(
-            col1, 
-            "webinar_script_audience", 
-            "webinar_script_product", 
-            webinar_formulas, 
-            "webinar_formula"
+    try:
+        model = get_model(temperature)
+        instruction = create_instruction(
+            format_type=format_type,
+            product_service=product,
+            skills=skills,
+            consciousness_level=consciousness_level,
+            target_audience=target_audience,
+            gender=None  # Adding gender parameter with None as default
         )
         
-        # Usar la función reutilizable para crear el botón personalizado
-        submit_webinar_script = create_custom_button("Generar Guión de Webinar", "generate_webinar_script")
-        
-        # Opciones avanzadas
-        with st.expander("Personaliza tu guión de webinar"):
-            webinar_script_temperature = st.slider("Creatividad", min_value=0.0, max_value=2.0, value=1.0, step=0.1, key="webinar_script_temp")
+        # Añadir instrucción explícita para respuesta en español
+        instruction += "\n\nIMPORTANTE: La respuesta debe estar completamente en español."
         
-        selected_webinar_formula = webinar_formulas[selected_webinar_formula_key]
+        response = model.generate_content([instruction], generation_config={"temperature": temperature})
+        return response.parts[0].text if response and response.parts else "Error generando el perfil de cliente ideal."
+    except Exception as e:
+        return f"Error al generar el perfil: {str(e)}"
+
+# Modificar la función update_profile para que no use spinner
+def update_profile():
+    # Solo actualizar la variable de sesión
+    st.session_state.submitted = True
+
+# Leer el contenido del archivo manual.md si existe
+try:
+    with open("manual.md", "r", encoding="utf-8") as file:
+        manual_content = file.read()
+    # Mostrar el contenido del manual en el sidebar
+    st.sidebar.markdown(manual_content)
+except FileNotFoundError:
+    st.sidebar.warning("Manual not found. Please create a manual.md file.")
+except Exception as e:
+    st.sidebar.error(f"Error loading manual: {str(e)}")
+
+# Ocultar elementos de la interfaz
+st.markdown(styles["main_layout"], unsafe_allow_html=True)
+
+# Centrar el título y el subtítulo
+st.markdown("<h1 style='text-align: center;'>Generador de Perfil de Cliente Ideal</h1>", unsafe_allow_html=True)
+st.markdown("<h4 style='text-align: center;'>Crea un perfil detallado de tu cliente ideal basado en tu producto y habilidades.</h4>", unsafe_allow_html=True)
+
+# Añadir CSS personalizado para el botón
+st.markdown(styles["button"], unsafe_allow_html=True)
+# Añadir CSS personalizado para el botón de descarga
+st.markdown(styles["download_button"], unsafe_allow_html=True)
+
+# Crear columnas
+col1, col2 = st.columns([1, 2])  
+
+# Columna de entrada
+with col1:
+    product = st.text_area("¿Qué producto o servicio ofreces?", 
+                          value=st.session_state.producto,
+                          placeholder="Ejemplo: Curso de Inglés",
+                          key="producto_input",
+                          height=70)
+    st.session_state.producto = product
     
-    # Generar y mostrar el guión usando la función reutilizable
-    if submit_webinar_script:
-        generate_and_display(
-            col2,
-            generate_webinar_script,
-            webinar_script_audience,
-            webinar_script_product,
-            webinar_script_temperature,
-            selected_webinar_formula,
-            content_type="script"
-        )
-
-# Segunda pestaña - Generador de Nombres de Webinar
-with tab2:
-    tab2.subheader("Nombres de Webinar")
+    skills = st.text_area("¿Cuáles son tus habilidades principales?", 
+                             value=st.session_state.habilidades,
+                             placeholder="Ejemplo: Enseñanza, comunicación, diseño de contenidos",
+                             key="habilidades_input",
+                             height=70)
+    st.session_state.habilidades = skills
     
-    # Crear columnas para la interfaz
-    col1, col2 = tab2.columns([1, 2])
+    # Botón para generar - Movido arriba del acordeón
+    submit = st.button("CREAR MI CLIENTE IDEAL SOÑADO ➤➤", on_click=update_profile)
     
-    # Columna de entrada usando la función reutilizable
-    with col1:
-        webinar_name_audience, webinar_name_product, selected_webinar_name_formula_key = create_input_section(
-            col1, 
-            "webinar_name_audience", 
-            "webinar_name_product", 
-            webinar_name_formulas, 
-            "webinar_name_formula"
+    # Crear un acordeón para las opciones de personalización
+    with st.expander("Personaliza Tu Cliente Ideal Soñado"):
+        # Nuevo campo para público objetivo
+        if 'publico_objetivo' not in st.session_state:
+            st.session_state.publico_objetivo = ""
+        
+        target_audience = st.text_area("¿Cuál es tu público objetivo? (opcional)", 
+                                      value=st.session_state.publico_objetivo,
+                                      placeholder="Ejemplo: Profesionales entre 25-40 años interesados en desarrollo personal",
+                                      key="publico_objetivo_input",
+                                      height=70)
+        st.session_state.publico_objetivo = target_audience
+        
+        # Selector de formato
+        from format.format import buyer_persona_formats
+        
+        # Usar directamente las claves del diccionario sin filtrar
+        format_type = st.selectbox(
+            "Formato del perfil",
+            options=list(buyer_persona_formats.keys()),
+            format_func=lambda x: x.capitalize(),
+            index=list(buyer_persona_formats.keys()).index(st.session_state.formato) if st.session_state.formato in buyer_persona_formats else 0,
+            help="Selecciona el formato en el que se presentará el perfil del cliente ideal"
         )
+        st.session_state.formato = format_type
         
-        number_of_names = st.selectbox("Número de nombres", options=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], index=4, key="number_of_names")
+        # Nivel de creatividad con slider
+        temperature = st.slider("Nivel de creatividad", 
+                               min_value=0.0, 
+                               max_value=2.0, 
+                               value=st.session_state.creatividad, 
+                               step=0.1,
+                               key="creatividad_slider")
+        st.session_state.creatividad = temperature
         
-        # Usar la función reutilizable para crear el botón personalizado
-        submit_webinar_names = create_custom_button("Generar Nombres de Webinar", "generate_webinar_names")
-
-        # Opciones avanzadas
-        with st.expander("Personaliza tus nombres de webinar"):
-            webinar_name_temperature = st.slider("Creatividad", min_value=0.0, max_value=2.0, value=1.0, step=0.1, key="webinar_name_temp")
-
-            # Configurar opciones de ángulo
-            angle_keys = ["NINGUNO"] + sorted([key for key in angles_webinar_names.keys() if key != "NINGUNO"])
-            selected_angle = st.selectbox(
-                "Selecciona el ángulo para tus nombres",
-                options=angle_keys,
-                key="webinar_name_angle"
-            )
-
-        selected_webinar_name_formula = webinar_name_formulas[selected_webinar_name_formula_key]
-
-    # Generar y mostrar los nombres usando la función reutilizable
-    if submit_webinar_names:
-        generate_and_display(
-            col2,
-            generate_webinar_names,
-            webinar_name_audience,
-            webinar_name_product,
-            webinar_name_temperature,
-            selected_webinar_name_formula,
-            content_type="names",
-            number_of_names=number_of_names,
-            selected_angle=selected_angle if selected_angle != "NINGUNO" else None
+        # Selector de nivel de conciencia
+        consciousness_options = []
+        for i, key in enumerate(CONSCIOUSNESS_LEVELS.keys(), 1):
+            # Replace underscores with spaces in the key
+            display_name = key.replace("_", " ")
+            consciousness_options.append(f"Nivel {i} - {display_name}")
+        
+        nivel_conciencia_display = st.selectbox(
+            "Nivel de conciencia del cliente ideal",
+            consciousness_options,
+            index=0,
+            help="Selecciona el nivel de conciencia en el que se encuentra tu cliente ideal"
         )
-        if validate_inputs(webinar_name_audience, webinar_name_product):
-            try:
-                with col2:
-                    with st.spinner("Generando tus nombres de webinar...", show_time=True):
-                        generated_webinar_names = generate_webinar_names(
-                            number_of_names,
-                            webinar_name_audience,
-                            webinar_name_product,
-                            webinar_name_temperature,
-                            selected_webinar_name_formula,
-                            selected_angle if selected_angle != "NINGUNO" else None
-                        )
-                    st.subheader("Tus nombres de webinar:")
-                    st.markdown(generated_webinar_names)
-            except ValueError as e:
-                col2.error(f"Error: {str(e)}")
+        
+        # Extract the original key from the display name
+        level_number = nivel_conciencia_display.split(" - ")[0].replace("Nivel ", "")
+        original_key = list(CONSCIOUSNESS_LEVELS.keys())[int(level_number) - 1]
+        nivel_conciencia = original_key.replace("_", " ")
+        
+        # Get the description from the CONSCIOUSNESS_LEVELS dictionary
+        if original_key in CONSCIOUSNESS_LEVELS:
+            nivel_info = CONSCIOUSNESS_LEVELS[original_key]["estado_mental"]
+            st.info(f"**{nivel_conciencia}**: {nivel_info}")
+            
+        st.session_state.nivel_conciencia = nivel_conciencia
+
+# Columna de resultados
+with col2:
+    # Verificar si se ha enviado el formulario
+    if 'submitted' in st.session_state and st.session_state.submitted:
+        if st.session_state.producto and st.session_state.habilidades:
+            with st.spinner("Creando tu Cliente Ideal Soñado..."):
+                # Generar el perfil del cliente
+                buyer_persona = generate_buyer_persona(
+                    st.session_state.producto,
+                    st.session_state.habilidades,
+                    st.session_state.publico_objetivo,
+                    st.session_state.creatividad,
+                    st.session_state.nivel_conciencia,
+                    st.session_state.formato
+                )
+                
+                # Mejorar la limpieza del perfil para eliminar estructuras JSON/diccionario
+                if isinstance(buyer_persona, str):
+                    import re
+                    import json
+                    
+                    # Eliminar marcadores de código markdown como ```json, ```python, etc.
+                    buyer_persona = re.sub(r'```[a-z]*\n', '', buyer_persona)
+                    buyer_persona = re.sub(r'```', '', buyer_persona)
+                    
+                    # Intentar detectar y limpiar formato JSON
+                    if '{' in buyer_persona and '}' in buyer_persona:
+                        # Intentar extraer solo el contenido textual, eliminando estructuras JSON
+                        # Primero, intentar encontrar el JSON completo
+                        json_pattern = r'(\{.*?\})'
+                        json_matches = re.findall(json_pattern, buyer_persona, re.DOTALL)
+                        
+                        if json_matches:
+                            for json_match in json_matches:
+                                # Intentar extraer el contenido real del JSON
+                                try:
+                                    # Reemplazar el JSON con una cadena vacía
+                                    buyer_persona = buyer_persona.replace(json_match, '')
+                                except:
+                                    pass
+                        
+                        # Limpiar líneas que parecen ser parte de un diccionario
+                        lines = buyer_persona.split('\n')
+                        cleaned_lines = []
+                        for line in lines:
+                            # Omitir líneas que parecen ser claves de diccionario
+                            if not re.match(r'^\s*["\']?[a-zA-Z_]+["\']?\s*:', line):
+                                cleaned_lines.append(line)
+                        
+                        buyer_persona = '\n'.join(cleaned_lines)
+                        
+                        # Eliminar llaves sueltas y corchetes
+                        buyer_persona = re.sub(r'[{}[\]]', '', buyer_persona)
+                        
+                        # Eliminar comillas y dos puntos que parecen ser de un diccionario
+                        buyer_persona = re.sub(r'["\']\s*:\s*["\']', '', buyer_persona)
+                        
+                        # Eliminar "template", "description", "example" y otras palabras clave comunes en el formato
+                        keywords = ["template", "description", "example", "Nivel de conciencia"]
+                        for keyword in keywords:
+                            buyer_persona = re.sub(rf'["\']?{keyword}["\']?\s*:\s*["\']?', '', buyer_persona)
+                        
+                        # Eliminar comillas sueltas
+                        buyer_persona = re.sub(r'^\s*["\']|["\']$', '', buyer_persona)
+                    
+                    # Normalizar espacios en blanco y sangrías
+                    lines = buyer_persona.split('\n')
+                    cleaned_lines = []
+                    for line in lines:
+                        # Eliminar sangrías excesivas pero mantener estructura básica
+                        cleaned_line = line.strip()
+                        if cleaned_line:  # Solo agregar líneas no vacías
+                            cleaned_lines.append(cleaned_line)
+                    
+                    # Unir las líneas con saltos de línea adecuados
+                    buyer_persona = '\n'.join(cleaned_lines)
+                    
+                    # Eliminar espacios en blanco adicionales
+                    buyer_persona = re.sub(r'\n\s*\n', '\n\n', buyer_persona)
+                    buyer_persona = buyer_persona.strip()
+                    
+                    # Al inicio del archivo, junto con las otras inicializaciones
+                    if 'perfil_cliente_plain' not in st.session_state:
+                        st.session_state.perfil_cliente_plain = None
+                    
+                    # Guardar versión sin formato antes de aplicar estilos HTML
+                    st.session_state.perfil_cliente_plain = buyer_persona
+                    
+                    # Convertir los asteriscos de formato Markdown a HTML para una correcta visualización
+                    # Convertir **texto** a <strong>texto</strong>
+                    buyer_persona = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', buyer_persona)
+                    # Convertir *texto* a <em>texto</em>
+                    buyer_persona = re.sub(r'\*(.*?)\*', r'<em>\1</em>', buyer_persona)
+                    
+                    # Mejorar el formato HTML para una mejor visualización
+                    buyer_persona = """
+                    <div style="line-height: 1.3; text-align: left;">
+                        {}
+                    </div>
+                    """.format(buyer_persona.replace('\n', '<br><br>'))
+                
+                # Guardar en session_state
+                st.session_state.perfil_cliente = buyer_persona
+                # Resetear el estado de envío
+                st.session_state.submitted = False
+                
+            # Mostrar resultados
+            if not isinstance(st.session_state.perfil_cliente, str):
+                st.error("Error al generar el perfil de cliente ideal")
+            else:
+                # Crear un contenedor para el resultado
+                result_container = st.container()
+                
+                # Aplicar estilos del contenedor
+                st.markdown(styles["results_container"], unsafe_allow_html=True)
+                
+                with result_container:
+                    # Mostrar el título
+                    st.markdown("<div class='results-title'>Tu Cliente Ideal</div>", unsafe_allow_html=True)
+                    
+                    # Mostrar el contenido como HTML para asegurar el formato correcto
+                    st.markdown(st.session_state.perfil_cliente, unsafe_allow_html=True)
+                
+                # Opción para descargar
+                # En la sección de descarga anterior, asegurarse de usar la versión plain si existe
+                st.download_button(
+                    label="DESCARGAR MI CLIENTE SOÑADO ➤➤",
+                    data=st.session_state.perfil_cliente_plain if st.session_state.perfil_cliente_plain else st.session_state.perfil_cliente,
+                    file_name="cliente_ideal.txt",
+                    mime="text/plain"
+                )
         else:
-            col2.error("Por favor, proporciona el público objetivo y el tema del webinar.")
-
+            st.warning("Por favor, completa los campos de producto y habilidades antes de generar el perfil.")
+    # Mostrar resultados anteriores si existen
+    elif st.session_state.perfil_cliente:
+        # Crear un contenedor para el resultado
+        result_container = st.container()
+        
+        # Aplicar estilos del contenedor
+        st.markdown(styles["results_container"], unsafe_allow_html=True)
+        
+        with result_container:
+            # Mostrar el título
+            st.markdown("<div class='results-title'>Tu Cliente Ideal</div>", unsafe_allow_html=True)
+            
+            # Mostrar el contenido como HTML para asegurar el formato correcto
+            st.markdown(st.session_state.perfil_cliente, unsafe_allow_html=True)
+        
+        # Opción para descargar
+        st.download_button(
+            label="DESCARGAR MI CLIENTE SOÑADO ➤➤",
+            data=st.session_state.perfil_cliente,
+            file_name="cliente_ideal.txt",
+            mime="text/plain"
+        )