fusesell 1.2.0__py3-none-any.whl

fusesell_local/config/__init__.py

@@ -0,0 +1,11 @@
+"""
+FuseSell Configuration - Configuration management and templates
+"""
+
+from .prompts import PromptManager
+from .settings import ConfigManager
+
+__all__ = [
+    'PromptManager',
+    'ConfigManager'
+]

fusesell_local/config/prompts.py

@@ -0,0 +1,245 @@
+"""
+Prompt Manager for FuseSell Local
+Handles LLM prompt templates and variable substitution
+"""
+
+from typing import Dict, Any, Optional
+import re
+import logging
+from .settings import ConfigManager
+
+
+class PromptManager:
+    """
+    Manages LLM prompts with template substitution and customization.
+    """
+    
+    def __init__(self, config_manager: ConfigManager):
+        """
+        Initialize prompt manager.
+        
+        Args:
+            config_manager: Configuration manager instance
+        """
+        self.config_manager = config_manager
+        self.logger = logging.getLogger("fusesell.prompts")
+    
+    def get_prompt(
+        self, 
+        stage: str, 
+        prompt_key: str, 
+        variables: Optional[Dict[str, Any]] = None,
+        team_id: Optional[str] = None,
+        language: str = "english"
+    ) -> str:
+        """
+        Get formatted prompt for a specific stage and key.
+        
+        Args:
+            stage: Pipeline stage name
+            prompt_key: Specific prompt identifier
+            variables: Variables for template substitution
+            team_id: Optional team ID for customization
+            language: Language for prompts
+            
+        Returns:
+            Formatted prompt string
+        """
+        try:
+            # Get prompts configuration
+            prompts = self.config_manager.get_prompts(team_id, language)
+            
+            # Get stage-specific prompts
+            stage_prompts = prompts.get(stage, {})
+            if not stage_prompts:
+                self.logger.warning(f"No prompts found for stage: {stage}")
+                return ""
+            
+            # Get specific prompt template
+            prompt_template = stage_prompts.get(prompt_key, "")
+            if not prompt_template:
+                self.logger.warning(f"No prompt found for {stage}.{prompt_key}")
+                return ""
+            
+            # Apply variable substitution
+            if variables:
+                prompt_template = self._substitute_variables(prompt_template, variables)
+            
+            return prompt_template
+            
+        except Exception as e:
+            self.logger.error(f"Failed to get prompt {stage}.{prompt_key}: {str(e)}")
+            return ""
+    
+    def get_data_acquisition_prompts(self, variables: Dict[str, Any], **kwargs) -> Dict[str, str]:
+        """Get all prompts for data acquisition stage."""
+        return {
+            'website_extraction': self.get_prompt('data_acquisition', 'website_extraction', variables, **kwargs),
+            'business_card_ocr': self.get_prompt('data_acquisition', 'business_card_ocr', variables, **kwargs),
+            'social_media_analysis': self.get_prompt('data_acquisition', 'social_media_analysis', variables, **kwargs),
+            'data_consolidation': self.get_prompt('data_acquisition', 'data_consolidation', variables, **kwargs)
+        }
+    
+    def get_data_preparation_prompts(self, variables: Dict[str, Any], **kwargs) -> Dict[str, str]:
+        """Get all prompts for data preparation stage."""
+        return {
+            'extract_company_info': self.get_prompt('data_preparation', 'extract_company_info', variables, **kwargs),
+            'identify_pain_points': self.get_prompt('data_preparation', 'identify_pain_points', variables, **kwargs),
+            'financial_analysis': self.get_prompt('data_preparation', 'financial_analysis', variables, **kwargs),
+            'development_plans': self.get_prompt('data_preparation', 'development_plans', variables, **kwargs),
+            'technology_analysis': self.get_prompt('data_preparation', 'technology_analysis', variables, **kwargs)
+        }
+    
+    def get_lead_scoring_prompts(self, variables: Dict[str, Any], **kwargs) -> Dict[str, str]:
+        """Get all prompts for lead scoring stage."""
+        return {
+            'evaluate_fit': self.get_prompt('lead_scoring', 'evaluate_fit', variables, **kwargs),
+            'score_calculation': self.get_prompt('lead_scoring', 'score_calculation', variables, **kwargs),
+            'competitive_analysis': self.get_prompt('lead_scoring', 'competitive_analysis', variables, **kwargs),
+            'recommendation': self.get_prompt('lead_scoring', 'recommendation', variables, **kwargs)
+        }
+    
+    def get_initial_outreach_prompts(self, variables: Dict[str, Any], **kwargs) -> Dict[str, str]:
+        """Get all prompts for initial outreach stage."""
+        return {
+            'email_generation': self.get_prompt('initial_outreach', 'email_generation', variables, **kwargs),
+            'subject_line': self.get_prompt('initial_outreach', 'subject_line', variables, **kwargs),
+            'tone_adjustment': self.get_prompt('initial_outreach', 'tone_adjustment', variables, **kwargs),
+            'personalization': self.get_prompt('initial_outreach', 'personalization', variables, **kwargs)
+        }
+    
+    def get_follow_up_prompts(self, variables: Dict[str, Any], **kwargs) -> Dict[str, str]:
+        """Get all prompts for follow-up stage."""
+        return {
+            'analyze_interaction': self.get_prompt('follow_up', 'analyze_interaction', variables, **kwargs),
+            'generate_followup': self.get_prompt('follow_up', 'generate_followup', variables, **kwargs),
+            'timing_analysis': self.get_prompt('follow_up', 'timing_analysis', variables, **kwargs),
+            'sequence_planning': self.get_prompt('follow_up', 'sequence_planning', variables, **kwargs)
+        }
+    
+    def _substitute_variables(self, template: str, variables: Dict[str, Any]) -> str:
+        """
+        Substitute variables in prompt template.
+        
+        Args:
+            template: Prompt template with placeholders
+            variables: Variables to substitute
+            
+        Returns:
+            Template with variables substituted
+        """
+        try:
+            # Handle nested dictionary access (e.g., {customer.name})
+            def replace_nested(match):
+                var_path = match.group(1)
+                value = self._get_nested_value(variables, var_path)
+                return str(value) if value is not None else f"{{{var_path}}}"
+            
+            # Replace {variable} and {nested.variable} patterns
+            result = re.sub(r'\{([^}]+)\}', replace_nested, template)
+            
+            return result
+            
+        except Exception as e:
+            self.logger.warning(f"Variable substitution failed: {str(e)}")
+            return template
+    
+    def _get_nested_value(self, data: Dict[str, Any], path: str) -> Any:
+        """
+        Get value from nested dictionary using dot notation.
+        
+        Args:
+            data: Dictionary to search
+            path: Dot-separated path (e.g., 'customer.name')
+            
+        Returns:
+            Value at path or None if not found
+        """
+        try:
+            keys = path.split('.')
+            value = data
+            
+            for key in keys:
+                if isinstance(value, dict) and key in value:
+                    value = value[key]
+                else:
+                    return None
+            
+            return value
+            
+        except Exception:
+            return None
+    
+    def validate_prompt_variables(self, template: str, variables: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate that all required variables are provided for a template.
+        
+        Args:
+            template: Prompt template
+            variables: Available variables
+            
+        Returns:
+            Dictionary with validation results
+        """
+        # Find all variable placeholders
+        placeholders = re.findall(r'\{([^}]+)\}', template)
+        
+        missing_vars = []
+        available_vars = []
+        
+        for placeholder in placeholders:
+            value = self._get_nested_value(variables, placeholder)
+            if value is None:
+                missing_vars.append(placeholder)
+            else:
+                available_vars.append(placeholder)
+        
+        return {
+            'valid': len(missing_vars) == 0,
+            'missing_variables': missing_vars,
+            'available_variables': available_vars,
+            'total_placeholders': len(placeholders)
+        }
+    
+    def create_variable_context(self, 
+                              customer_data: Optional[Dict[str, Any]] = None,
+                              lead_scores: Optional[Dict[str, Any]] = None,
+                              org_info: Optional[Dict[str, Any]] = None,
+                              team_info: Optional[Dict[str, Any]] = None,
+                              **additional_vars) -> Dict[str, Any]:
+        """
+        Create a comprehensive variable context for prompt substitution.
+        
+        Args:
+            customer_data: Customer information
+            lead_scores: Lead scoring results
+            org_info: Organization information
+            team_info: Team information
+            **additional_vars: Additional variables
+            
+        Returns:
+            Complete variable context
+        """
+        context = {}
+        
+        if customer_data:
+            context['customer'] = customer_data
+            context['company'] = customer_data.get('companyInfo', {})
+            context['contact'] = customer_data.get('primaryContact', {})
+            context['pain_points'] = customer_data.get('painPoints', [])
+        
+        if lead_scores:
+            context['lead_scores'] = lead_scores
+            context['top_score'] = max(lead_scores.get('scores', []), key=lambda x: x.get('score', 0), default={})
+        
+        if org_info:
+            context['org'] = org_info
+            context['seller'] = org_info
+        
+        if team_info:
+            context['team'] = team_info
+        
+        # Add additional variables
+        context.update(additional_vars)
+        
+        return context

fusesell_local/config/settings.py

@@ -0,0 +1,277 @@
+"""
+Configuration Manager for FuseSell Local
+Handles team-specific settings, prompts, and business rules
+"""
+
+import json
+from typing import Dict, Any, Optional
+from pathlib import Path
+import logging
+
+
+class ConfigManager:
+    """
+    Manages configuration settings for FuseSell Local.
+    Handles team-specific prompts, scoring criteria, and business rules.
+    """
+    
+    def __init__(self, data_dir: str = "./fusesell_data"):
+        """
+        Initialize configuration manager.
+        
+        Args:
+            data_dir: Directory containing configuration files
+        """
+        self.data_dir = Path(data_dir)
+        self.config_dir = self.data_dir / "config"
+        self.logger = logging.getLogger("fusesell.config")
+        
+        # Ensure config directory exists
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Cache for loaded configurations
+        self._cache = {}
+    
+    def get_prompts(self, team_id: Optional[str] = None, language: str = "english") -> Dict[str, Any]:
+        """
+        Get LLM prompts for stages, with team and language customization.
+        
+        Args:
+            team_id: Optional team ID for team-specific prompts
+            language: Language for prompts
+            
+        Returns:
+            Dictionary of prompts organized by stage
+        """
+        cache_key = f"prompts_{team_id}_{language}"
+        
+        if cache_key in self._cache:
+            return self._cache[cache_key]
+        
+        # Load base prompts
+        base_prompts = self._load_json_config("prompts.json", {})
+        
+        # Apply team customizations if available
+        if team_id:
+            team_prompts = self._load_team_prompts(team_id, language)
+            base_prompts = self._merge_configs(base_prompts, team_prompts)
+        
+        # Apply language customizations
+        if language != "english":
+            lang_prompts = self._load_language_prompts(language)
+            base_prompts = self._merge_configs(base_prompts, lang_prompts)
+        
+        self._cache[cache_key] = base_prompts
+        return base_prompts
+    
+    def get_scoring_criteria(self, team_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Get lead scoring criteria with team customization.
+        
+        Args:
+            team_id: Optional team ID for team-specific criteria
+            
+        Returns:
+            Dictionary of scoring criteria and weights
+        """
+        cache_key = f"scoring_{team_id}"
+        
+        if cache_key in self._cache:
+            return self._cache[cache_key]
+        
+        # Load base scoring criteria
+        base_criteria = self._load_json_config("scoring_criteria.json", {})
+        
+        # Apply team customizations if available
+        if team_id:
+            team_criteria = self._load_team_scoring(team_id)
+            base_criteria = self._merge_configs(base_criteria, team_criteria)
+        
+        self._cache[cache_key] = base_criteria
+        return base_criteria
+    
+    def get_email_templates(self, team_id: Optional[str] = None, language: str = "english") -> Dict[str, Any]:
+        """
+        Get email templates with team and language customization.
+        
+        Args:
+            team_id: Optional team ID for team-specific templates
+            language: Language for templates
+            
+        Returns:
+            Dictionary of email templates
+        """
+        cache_key = f"templates_{team_id}_{language}"
+        
+        if cache_key in self._cache:
+            return self._cache[cache_key]
+        
+        # Load base templates
+        base_templates = self._load_json_config("email_templates.json", {})
+        
+        # Apply team customizations if available
+        if team_id:
+            team_templates = self._load_team_templates(team_id, language)
+            base_templates = self._merge_configs(base_templates, team_templates)
+        
+        # Apply language customizations
+        if language != "english":
+            lang_templates = self._load_language_templates(language)
+            base_templates = self._merge_configs(base_templates, lang_templates)
+        
+        self._cache[cache_key] = base_templates
+        return base_templates
+    
+    def get_business_rules(self, team_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Get business rules and pipeline behavior settings.
+        
+        Args:
+            team_id: Optional team ID for team-specific rules
+            
+        Returns:
+            Dictionary of business rules
+        """
+        cache_key = f"rules_{team_id}"
+        
+        if cache_key in self._cache:
+            return self._cache[cache_key]
+        
+        # Default business rules based on original system
+        default_rules = {
+            "pipeline": {
+                "stop_on_website_fail": True,
+                "wait_after_draft_generation": True,
+                "max_operations": 10,
+                "max_simultaneous_operations": 1,
+                "sequential_execution_only": True
+            },
+            "data_acquisition": {
+                "min_execution_time_seconds": 100,
+                "required_sources": ["website"],
+                "optional_sources": ["business_card", "linkedin", "facebook"]
+            },
+            "initial_outreach": {
+                "actions": ["draft_write", "draft_rewrite", "send", "close"],
+                "default_action": "draft_write",
+                "require_human_approval": True,
+                "one_action_per_trigger": True
+            },
+            "follow_up": {
+                "actions": ["draft_write", "draft_rewrite", "send"],
+                "require_explicit_trigger": True,
+                "analyze_previous_interactions": True
+            }
+        }
+        
+        # Apply team customizations if available
+        if team_id:
+            team_rules = self._load_team_rules(team_id)
+            default_rules = self._merge_configs(default_rules, team_rules)
+        
+        self._cache[cache_key] = default_rules
+        return default_rules
+    
+    def _load_json_config(self, filename: str, default: Dict[str, Any]) -> Dict[str, Any]:
+        """Load JSON configuration file with fallback to default."""
+        try:
+            config_file = self.config_dir / filename
+            if config_file.exists():
+                with open(config_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+        except Exception as e:
+            self.logger.warning(f"Failed to load {filename}: {str(e)}")
+        
+        return default.copy()
+    
+    def _load_team_prompts(self, team_id: str, language: str) -> Dict[str, Any]:
+        """Load team-specific prompts."""
+        team_file = self.config_dir / f"team_{team_id}_prompts_{language}.json"
+        return self._load_json_config(team_file.name, {})
+    
+    def _load_team_scoring(self, team_id: str) -> Dict[str, Any]:
+        """Load team-specific scoring criteria."""
+        team_file = self.config_dir / f"team_{team_id}_scoring.json"
+        return self._load_json_config(team_file.name, {})
+    
+    def _load_team_templates(self, team_id: str, language: str) -> Dict[str, Any]:
+        """Load team-specific email templates."""
+        team_file = self.config_dir / f"team_{team_id}_templates_{language}.json"
+        return self._load_json_config(team_file.name, {})
+    
+    def _load_team_rules(self, team_id: str) -> Dict[str, Any]:
+        """Load team-specific business rules."""
+        team_file = self.config_dir / f"team_{team_id}_rules.json"
+        return self._load_json_config(team_file.name, {})
+    
+    def _load_language_prompts(self, language: str) -> Dict[str, Any]:
+        """Load language-specific prompts."""
+        lang_file = self.config_dir / f"prompts_{language}.json"
+        return self._load_json_config(lang_file.name, {})
+    
+    def _load_language_templates(self, language: str) -> Dict[str, Any]:
+        """Load language-specific email templates."""
+        lang_file = self.config_dir / f"templates_{language}.json"
+        return self._load_json_config(lang_file.name, {})
+    
+    def _merge_configs(self, base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Recursively merge configuration dictionaries.
+        
+        Args:
+            base: Base configuration
+            override: Override configuration
+            
+        Returns:
+            Merged configuration
+        """
+        result = base.copy()
+        
+        for key, value in override.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = self._merge_configs(result[key], value)
+            else:
+                result[key] = value
+        
+        return result
+    
+    def save_team_config(self, team_id: str, config_type: str, config_data: Dict[str, Any], language: str = "english") -> None:
+        """
+        Save team-specific configuration.
+        
+        Args:
+            team_id: Team identifier
+            config_type: Type of config (prompts, scoring, templates, rules)
+            config_data: Configuration data to save
+            language: Language for prompts/templates
+        """
+        try:
+            if config_type in ["prompts", "templates"]:
+                filename = f"team_{team_id}_{config_type}_{language}.json"
+            else:
+                filename = f"team_{team_id}_{config_type}.json"
+            
+            config_file = self.config_dir / filename
+            
+            with open(config_file, 'w', encoding='utf-8') as f:
+                json.dump(config_data, f, indent=2, ensure_ascii=False)
+            
+            # Clear cache for this team
+            self._clear_team_cache(team_id)
+            
+            self.logger.info(f"Saved team configuration: {filename}")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to save team config {config_type} for {team_id}: {str(e)}")
+            raise
+    
+    def _clear_team_cache(self, team_id: str) -> None:
+        """Clear cached configurations for a specific team."""
+        keys_to_remove = [key for key in self._cache.keys() if team_id in key]
+        for key in keys_to_remove:
+            del self._cache[key]
+    
+    def clear_cache(self) -> None:
+        """Clear all cached configurations."""
+        self._cache.clear()
+        self.logger.debug("Configuration cache cleared")