first big update lmao

engine.py

@@ -0,0 +1,110 @@
+import json
+from graph_module import Graph
+from algorithms import bellman_ford_list
+
+
+class SalesEngine:
+    def __init__(self, json_file='sales_script.json'):
+        """Initialize the SalesEngine by loading the sales script from JSON."""
+        # Load the sales script
+        with open(json_file, 'r') as f:
+            data = json.load(f)
+        
+        self.nodes_data = data['nodes']
+        self.edges_data = data['edges']
+        
+        # Create mapping from string IDs to integer IDs
+        self.str_to_int = {}
+        self.int_to_str = {}
+        self.node_text = {}
+        
+        for idx, node_name in enumerate(self.nodes_data.keys()):
+            self.str_to_int[node_name] = idx
+            self.int_to_str[idx] = node_name
+            self.node_text[node_name] = self.nodes_data[node_name]
+        
+        # Build the Graph object
+        num_nodes = len(self.nodes_data)
+        self.graph = Graph(num_nodes, directed=True)
+        
+        # Add edges with weights
+        for edge in self.edges_data:
+            from_node = self.str_to_int[edge['from']]
+            to_node = self.str_to_int[edge['to']]
+            weight = edge['weight']
+            self.graph.add_edge(from_node, to_node, weight)
+    
+    def get_best_next_step(self, current_step_name):
+        """
+        Find the best next step from the current position to reach 'close_deal'.
+        
+        Args:
+            current_step_name: String name of the current step
+            
+        Returns:
+            Tuple of (next_step_name, next_step_text) for the optimal next step
+        """
+        # Find integer ID of current step
+        current_id = self.str_to_int[current_step_name]
+        
+        # Run Bellman-Ford from current step
+        distances = bellman_ford_list(self.graph, current_id)
+        
+        if distances is None:
+            raise ValueError("Negative cycle detected in the sales script graph!")
+        
+        # Find the close_deal node ID
+        close_deal_id = self.str_to_int['close_deal']
+        
+        # If we're already at close_deal, return it
+        if current_id == close_deal_id:
+            return current_step_name, self.node_text[current_step_name]
+        
+        # Find the best immediate next step
+        # Look at all neighbors of current node and pick the one with shortest total distance to close_deal
+        adj_list = self.graph.get_list()
+        best_next_id = None
+        best_total_distance = float('inf')
+        
+        for neighbor_id, edge_weight in adj_list[current_id]:
+            # Total distance = edge weight + distance from neighbor to close_deal
+            total_distance = edge_weight + distances[close_deal_id]
+            if total_distance < best_total_distance:
+                best_total_distance = total_distance
+                best_next_id = neighbor_id
+        
+        if best_next_id is None:
+            raise ValueError(f"No path found from '{current_step_name}' to 'close_deal'")
+        
+        # Convert back to string name and get text
+        next_step_name = self.int_to_str[best_next_id]
+        next_step_text = self.node_text[next_step_name]
+        
+        return next_step_name, next_step_text
+
+
+if __name__ == "__main__":
+    # Simulate a conversation path
+    engine = SalesEngine()
+    
+    current_step = "start"
+    print(f"Starting sales conversation at: {current_step}")
+    print(f">>> {engine.node_text[current_step]}\n")
+    
+    step_count = 0
+    max_steps = 10  # Safety limit to prevent infinite loops
+    
+    while current_step != "close_deal" and step_count < max_steps:
+        # Get the best next step
+        next_step, next_text = engine.get_best_next_step(current_step)
+        
+        print(f"Best next move: {next_step}")
+        print(f">>> {next_text}\n")
+        
+        current_step = next_step
+        step_count += 1
+    
+    if current_step == "close_deal":
+        print("[SUCCESS] Successfully reached the deal closure!")
+    else:
+        print("[WARNING] Reached maximum steps without closing the deal.")

sales_script.json

@@ -0,0 +1,70 @@
+{
+    "nodes": {
+        "start": "Привіт! Це AI-асистент SellMe. Маєте хвилинку?",
+        "qualification": "Скажіть, ви використовуєте CRM систему?",
+        "pitch_crm": "Круто! Наш AI інтегрується з вашою CRM і сам заповнює картки.",
+        "pitch_no_crm": "Зрозумів. Наш AI може працювати навіть без CRM, в Телеграмі.",
+        "price_question": "Скільки це коштує? - Це залежить від кількості менеджерів.",
+        "objection_expensive": "Дорого? А скільки ви втрачаєте на незакритих угодах?",
+        "discount_offer": "Можемо запропонувати тестовий період за 1$.",
+        "close_deal": "Домовились! Висилаю посилання на оплату.",
+        "exit_bad": "Добре, вибачте за турботу. Гарного дня."
+    },
+    "edges": [
+        {
+            "from": "start",
+            "to": "qualification",
+            "weight": 1
+        },
+        {
+            "from": "start",
+            "to": "exit_bad",
+            "weight": 100
+        },
+        {
+            "from": "qualification",
+            "to": "pitch_crm",
+            "weight": 2
+        },
+        {
+            "from": "qualification",
+            "to": "pitch_no_crm",
+            "weight": 2
+        },
+        {
+            "from": "pitch_crm",
+            "to": "price_question",
+            "weight": 2
+        },
+        {
+            "from": "pitch_no_crm",
+            "to": "price_question",
+            "weight": 3
+        },
+        {
+            "from": "price_question",
+            "to": "objection_expensive",
+            "weight": 5
+        },
+        {
+            "from": "price_question",
+            "to": "close_deal",
+            "weight": 10
+        },
+        {
+            "from": "objection_expensive",
+            "to": "exit_bad",
+            "weight": 50
+        },
+        {
+            "from": "objection_expensive",
+            "to": "discount_offer",
+            "weight": 1
+        },
+        {
+            "from": "discount_offer",
+            "to": "close_deal",
+            "weight": 1
+        }
+    ]
+}

sellme_demo.py

@@ -0,0 +1,157 @@
+import json
+import os
+import google.generativeai as genai
+from graph_module import Graph
+from algorithms import bellman_ford_list
+
+
+def main():
+    # Configuration: Get API Key from user
+    print("=" * 60)
+    print("SellMe AI Sales Demo - Powered by Gemini")
+    print("=" * 60)
+    api_key = input("\nEnter your Gemini API Key: ").strip()
+    
+    # Configure Gemini
+    genai.configure(api_key=api_key)
+    model = genai.GenerativeModel('gemini-1.5-flash')
+    
+    print("\n[INFO] Gemini configured successfully!")
+    print("[INFO] Loading sales script...\n")
+    
+    # Load sales_script.json
+    with open('sales_script.json', 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    nodes_data = data['nodes']
+    edges_data = data['edges']
+    
+    # Create mappings: string IDs <-> integer IDs
+    str_to_int = {}
+    int_to_str = {}
+    
+    for idx, node_name in enumerate(nodes_data.keys()):
+        str_to_int[node_name] = idx
+        int_to_str[idx] = node_name
+    
+    # Build Graph object
+    num_nodes = len(nodes_data)
+    graph = Graph(num_nodes, directed=True)
+    
+    # Add edges with weights
+    for edge in edges_data:
+        from_node = str_to_int[edge['from']]
+        to_node = str_to_int[edge['to']]
+        weight = edge['weight']
+        graph.add_edge(from_node, to_node, weight)
+    
+    print("[INFO] Sales graph built successfully!")
+    print(f"[INFO] Nodes: {num_nodes}, Edges: {len(edges_data)}\n")
+    print("=" * 60)
+    print("Starting Sales Conversation")
+    print("=" * 60)
+    print("(Type 'quit' to exit)\n")
+    
+    # Start conversation
+    current_step = "start"
+    conversation_count = 0
+    max_steps = 20  # Safety limit
+    
+    while current_step not in ["close_deal", "exit_bad"] and conversation_count < max_steps:
+        # Get current node ID
+        current_id = str_to_int[current_step]
+        
+        # Calculate best path to close_deal using Bellman-Ford
+        distances = bellman_ford_list(graph, current_id)
+        
+        if distances is None:
+            print("[ERROR] Negative cycle detected in sales graph!")
+            break
+        
+        # Get close_deal node ID
+        close_deal_id = str_to_int['close_deal']
+        
+        # Find the best immediate next step
+        adj_list = graph.get_list()
+        neighbors = adj_list[current_id]
+        
+        if not neighbors:
+            print(f"[ERROR] No path forward from '{current_step}'")
+            break
+        
+        # Pick the neighbor with shortest total distance to close_deal
+        best_next_id = None
+        best_total_distance = float('inf')
+        
+        for neighbor_id, edge_weight in neighbors:
+            # Run Bellman-Ford from this neighbor to find distance to close_deal
+            neighbor_distances = bellman_ford_list(graph, neighbor_id)
+            if neighbor_distances and neighbor_distances[close_deal_id] != float('inf'):
+                total_distance = edge_weight + neighbor_distances[close_deal_id]
+                if total_distance < best_total_distance:
+                    best_total_distance = total_distance
+                    best_next_id = neighbor_id
+        
+        if best_next_id is None:
+            print(f"[ERROR] No path found from '{current_step}' to 'close_deal'")
+            break
+        
+        # Get next step name and script text
+        next_step_name = int_to_str[best_next_id]
+        script_text = nodes_data[next_step_name]
+        
+        # Get user input (simulating client)
+        print(f"\n[CURRENT STEP: {current_step}]")
+        print(f"[NEXT TARGET: {next_step_name}]")
+        user_input = input("\nYou (Client): ").strip()
+        
+        if user_input.lower() == 'quit':
+            print("\n[INFO] Exiting demo. Goodbye!")
+            break
+        
+        # Create prompt for Gemini
+        prompt = f"""You are a professional sales representative for SellMe, an AI sales assistant platform.
+
+Your goal is to move the conversation toward this step: '{next_step_name}'.
+The sales script for this step says: '{script_text}'.
+The client just said: '{user_input}'.
+
+Generate a natural, conversational response in Ukrainian that:
+1. Acknowledges what the client said
+2. Smoothly guides toward the script message
+3. Sounds human and friendly, not robotic
+4. Keep it brief (1-2 sentences max)
+
+Response:"""
+        
+        # Get Gemini's response
+        print("\n[AI is thinking...]")
+        try:
+            response = model.generate_content(prompt)
+            ai_response = response.text.strip()
+            
+            print(f"\nSellMe AI: {ai_response}")
+            
+        except Exception as e:
+            print(f"\n[ERROR] Gemini API error: {e}")
+            print(f"[FALLBACK] Using script: {script_text}")
+        
+        # Move to next step
+        current_step = next_step_name
+        conversation_count += 1
+    
+    # End of conversation
+    print("\n" + "=" * 60)
+    if current_step == "close_deal":
+        print("[SUCCESS] Deal closed! 🎉")
+        print(f"Final message: {nodes_data[current_step]}")
+    elif current_step == "exit_bad":
+        print("[EXIT] Client not interested.")
+        print(f"Final message: {nodes_data[current_step]}")
+    else:
+        print(f"[INFO] Conversation ended at step: {current_step}")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

sellme_pro.py

@@ -0,0 +1,270 @@
+import json
+import os
+import google.generativeai as genai
+from graph_module import Graph
+from algorithms import bellman_ford_list
+
+
+def get_sentiment(user_text, model):
+    """
+    Analyze user sentiment using Gemini.
+    
+    Args:
+        user_text: The user's message
+        model: Gemini model instance
+        
+    Returns:
+        Float score from -1 (Angry) to +1 (Happy)
+    """
+    prompt = f"""Analyze the sentiment of this message and return ONLY a number between -1 and +1.
+-1 = Very angry, hostile, frustrated
+-0.5 = Slightly negative, uncertain
+0 = Neutral
++0.5 = Slightly positive, interested
++1 = Very happy, enthusiastic, eager
+
+Message: "{user_text}"
+
+Return only the number, nothing else:"""
+    
+    try:
+        response = model.generate_content(prompt)
+        sentiment_text = response.text.strip()
+        # Extract number from response
+        sentiment_score = float(sentiment_text)
+        # Clamp to [-1, 1] range
+        sentiment_score = max(-1.0, min(1.0, sentiment_score))
+        return sentiment_score
+    except Exception as e:
+        print(f"[WARNING] Sentiment analysis failed: {e}. Defaulting to neutral (0.0)")
+        return 0.0
+
+
+def update_weights(graph, str_to_int, original_edges, sentiment_score):
+    """
+    Dynamically update graph edge weights based on user sentiment.
+    
+    Args:
+        graph: The Graph object
+        str_to_int: Mapping from string node names to integer IDs
+        original_edges: Original edge data from JSON
+        sentiment_score: Float from -1 to +1
+    """
+    # Strategy mapping
+    close_deal_id = str_to_int.get('close_deal')
+    discount_offer_id = str_to_int.get('discount_offer')
+    exit_bad_id = str_to_int.get('exit_bad')
+    pitch_crm_id = str_to_int.get('pitch_crm')
+    pitch_no_crm_id = str_to_int.get('pitch_no_crm')
+    
+    # Rebuild graph with adjusted weights
+    for edge in original_edges:
+        from_id = str_to_int[edge['from']]
+        to_id = str_to_int[edge['to']]
+        original_weight = edge['weight']
+        adjusted_weight = original_weight
+        
+        # Negative sentiment (< -0.3): Customer is unhappy/frustrated
+        if sentiment_score < -0.3:
+            # INCREASE weights for aggressive moves (hard selling is bad now)
+            if to_id == close_deal_id or to_id in [pitch_crm_id, pitch_no_crm_id]:
+                adjusted_weight = original_weight * 2.0  # Make these paths less attractive
+            
+            # DECREASE weights for relationship-saving moves
+            if to_id == discount_offer_id or to_id == exit_bad_id:
+                adjusted_weight = original_weight * 0.5  # Make these paths more attractive
+        
+        # Positive sentiment (> 0.3): Customer is happy/interested
+        elif sentiment_score > 0.3:
+            # DECREASE weights for close_deal (strike while iron is hot!)
+            if to_id == close_deal_id:
+                adjusted_weight = original_weight * 0.3  # Make closing much more attractive
+            
+            # Also boost pitch effectiveness when customer is positive
+            if to_id in [pitch_crm_id, pitch_no_crm_id]:
+                adjusted_weight = original_weight * 0.7  # Make pitches more attractive
+        
+        # Update the graph (we need to rebuild adjacency structures)
+        # Since Graph doesn't have update_edge, we'll handle this in the main loop
+        graph.adj_matrix[from_id][to_id] = adjusted_weight
+        
+        # Update adjacency list
+        for i, (neighbor, _) in enumerate(graph.adj_list[from_id]):
+            if neighbor == to_id:
+                graph.adj_list[from_id][i] = (neighbor, adjusted_weight)
+                break
+
+
+def main():
+    # Configuration: Get API Key from user
+    print("=" * 60)
+    print("SellMe PRO - Dynamic Sentiment-Based Sales AI")
+    print("=" * 60)
+    api_key = input("\nEnter your Gemini API Key: ").strip()
+    
+    # Configure Gemini
+    genai.configure(api_key=api_key)
+    model = genai.GenerativeModel('gemini-1.5-pro')
+    
+    print("\n[INFO] Gemini configured successfully!")
+    print("[INFO] Loading sales script...\n")
+    
+    # Load sales_script.json
+    with open('sales_script.json', 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    nodes_data = data['nodes']
+    edges_data = data['edges']
+    
+    # Create mappings: string IDs <-> integer IDs
+    str_to_int = {}
+    int_to_str = {}
+    
+    for idx, node_name in enumerate(nodes_data.keys()):
+        str_to_int[node_name] = idx
+        int_to_str[idx] = node_name
+    
+    # Build Graph object
+    num_nodes = len(nodes_data)
+    graph = Graph(num_nodes, directed=True)
+    
+    # Add edges with original weights
+    for edge in edges_data:
+        from_node = str_to_int[edge['from']]
+        to_node = str_to_int[edge['to']]
+        weight = edge['weight']
+        graph.add_edge(from_node, to_node, weight)
+    
+    print("[INFO] Sales graph built successfully!")
+    print(f"[INFO] Nodes: {num_nodes}, Edges: {len(edges_data)}")
+    print("[INFO] Sentiment-based dynamic weighting enabled!\n")
+    print("=" * 60)
+    print("Starting Sales Conversation")
+    print("=" * 60)
+    print("(Type 'quit' to exit)\n")
+    
+    # Start conversation
+    current_step = "start"
+    conversation_count = 0
+    max_steps = 20  # Safety limit
+    
+    while current_step not in ["close_deal", "exit_bad"] and conversation_count < max_steps:
+        # Get current node ID
+        current_id = str_to_int[current_step]
+        
+        # Get user input first
+        print(f"\n[CURRENT STEP: {current_step}]")
+        user_input = input("\nYou (Client): ").strip()
+        
+        if user_input.lower() == 'quit':
+            print("\n[INFO] Exiting demo. Goodbye!")
+            break
+        
+        # === SENTIMENT ANALYSIS ===
+        print("\n[AI is analyzing sentiment...]")
+        sentiment_score = get_sentiment(user_input, model)
+        
+        # Determine sentiment category
+        if sentiment_score < -0.3:
+            sentiment_label = "NEGATIVE"
+        elif sentiment_score > 0.3:
+            sentiment_label = "POSITIVE"
+        else:
+            sentiment_label = "NEUTRAL"
+        
+        print(f">>> Detected Sentiment: {sentiment_score:.2f} [{sentiment_label}]")
+        
+        # === DYNAMIC WEIGHT UPDATE ===
+        if abs(sentiment_score) > 0.3:
+            print(">>> Strategy Changed! Adjusting conversation path...")
+            update_weights(graph, str_to_int, edges_data, sentiment_score)
+        
+        # Calculate best path with updated weights
+        distances = bellman_ford_list(graph, current_id)
+        
+        if distances is None:
+            print("[ERROR] Negative cycle detected in sales graph!")
+            break
+        
+        # Get close_deal node ID
+        close_deal_id = str_to_int['close_deal']
+        
+        # Find the best immediate next step
+        adj_list = graph.get_list()
+        neighbors = adj_list[current_id]
+        
+        if not neighbors:
+            print(f"[ERROR] No path forward from '{current_step}'")
+            break
+        
+        # Pick the neighbor with shortest total distance to close_deal
+        best_next_id = None
+        best_total_distance = float('inf')
+        
+        for neighbor_id, edge_weight in neighbors:
+            # Run Bellman-Ford from this neighbor to find distance to close_deal
+            neighbor_distances = bellman_ford_list(graph, neighbor_id)
+            if neighbor_distances and neighbor_distances[close_deal_id] != float('inf'):
+                total_distance = edge_weight + neighbor_distances[close_deal_id]
+                if total_distance < best_total_distance:
+                    best_total_distance = total_distance
+                    best_next_id = neighbor_id
+        
+        if best_next_id is None:
+            print(f"[ERROR] No path found from '{current_step}' to 'close_deal'")
+            break
+        
+        # Get next step name and script text
+        next_step_name = int_to_str[best_next_id]
+        script_text = nodes_data[next_step_name]
+        
+        print(f"[NEXT TARGET: {next_step_name}]")
+        
+        # Create prompt for Gemini
+        prompt = f"""You are a professional sales representative for SellMe, an AI sales assistant platform.
+
+Your goal is to move the conversation toward this step: '{next_step_name}'.
+The sales script for this step says: '{script_text}'.
+The client just said: '{user_input}'.
+Client sentiment: {sentiment_score:.2f} ({sentiment_label})
+
+Generate a natural, conversational response in Ukrainian that:
+1. Acknowledges what the client said and their emotional state
+2. Smoothly guides toward the script message
+3. Adjusts tone based on sentiment (softer if negative, enthusiastic if positive)
+4. Sounds human and friendly, not robotic
+5. Keep it brief (1-2 sentences max)
+
+Response:"""
+        
+        # Get Gemini's response
+        print("\n[AI is generating response...]")
+        try:
+            response = model.generate_content(prompt)
+            ai_response = response.text.strip()
+            
+            print(f"\nSellMe AI: {ai_response}")
+            
+        except Exception as e:
+            print(f"\n[ERROR] Gemini API error: {e}")
+            print(f"[FALLBACK] Using script: {script_text}")
+        
+        # Move to next step
+        current_step = next_step_name
+        conversation_count += 1
+    
+    # End of conversation
+    print("\n" + "=" * 60)
+    if current_step == "close_deal":
+        print("[SUCCESS] Deal closed!")
+        print(f"Final message: {nodes_data[current_step]}")
+    elif current_step == "exit_bad":
+        print("[EXIT] Client not interested.")
+        print(f"Final message: {nodes_data[current_step]}")
+    else:
+        print(f"[INFO] Conversation ended at step: {current_step}")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()