fusesell 1.2.5__tar.gz → 1.2.6__tar.gz

{fusesell-1.2.5 → fusesell-1.2.6}/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to FuseSell Local will be documented in this file.
 
+# [1.2.6] - 2025-10-24
+
+### Added
+- Automatically seed packaged prompt, scoring, and template JSON files into the writable `fusesell_data/config` directory so fresh installs immediately pick up the default initial outreach draft prompt.
+- Draft generation now records the scheduled reminder metadata in stage output while mirroring the server’s `schedule_auto_run` behaviour locally.
+
+### Fixed
+- Bundled configuration files are used as a fallback when the data directory is missing overrides, preventing empty prompt loads that previously produced low-quality duplicate drafts.
+
 # [1.2.5] - 2025-10-24
 
 ### Added

{fusesell-1.2.5/fusesell.egg-info → fusesell-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fusesell
-Version: 1.2.5
+Version: 1.2.6
 Summary: Local implementation of FuseSell AI sales automation pipeline
 Author-email: FuseSell Team <team@fusesell.ai>
 License-Expression: MIT

{fusesell-1.2.5 → fusesell-1.2.6/fusesell.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fusesell
-Version: 1.2.5
+Version: 1.2.6
 Summary: Local implementation of FuseSell AI sales automation pipeline
 Author-email: FuseSell Team <team@fusesell.ai>
 License-Expression: MIT

{fusesell-1.2.5 → fusesell-1.2.6}/fusesell_local/__init__.py

@@ -32,6 +32,6 @@ __all__ = [
     "validate_config",
 ]
 
-__version__ = "1.2.5"
+__version__ = "1.2.6"
 __author__ = "FuseSell Team"
 __description__ = "Local implementation of FuseSell AI sales automation pipeline"

{fusesell-1.2.5 → fusesell-1.2.6}/fusesell_local/stages/initial_outreach.py

@@ -102,23 +102,32 @@ class InitialOutreachStage(BaseStage):
         # Generate multiple email drafts
         email_drafts = self._generate_email_drafts(customer_data, recommended_product, scoring_data, context)
         
-        # Save drafts to local files and database
-        saved_drafts = self._save_email_drafts(context, email_drafts)
-        
-        # Prepare final output
-        outreach_data = {
-            'action': 'draft_write',
-            'status': 'drafts_generated',
+        # Save drafts to local files and database
+        saved_drafts = self._save_email_drafts(context, email_drafts)
+
+        schedule_summary = self._schedule_initial_reminder_for_drafts(
+            saved_drafts,
+            customer_data,
+            context
+        )
+        
+        # Prepare final output
+        outreach_data = {
+            'action': 'draft_write',
+            'status': 'drafts_generated',
             'email_drafts': saved_drafts,
             'recommended_product': recommended_product,
             'customer_summary': self._create_customer_summary(customer_data),
             'total_drafts_generated': len(saved_drafts),
-            'generation_timestamp': datetime.now().isoformat(),
-            'customer_id': context.get('execution_id')
-        }
-        
-        # Save to database
-        self.save_stage_result(context, outreach_data)
+            'generation_timestamp': datetime.now().isoformat(),
+            'customer_id': context.get('execution_id')
+        }
+
+        if schedule_summary:
+            outreach_data['reminder_schedule'] = schedule_summary
+        
+        # Save to database
+        self.save_stage_result(context, outreach_data)
         
         result = self.create_success_result(outreach_data, context)
         return result
@@ -363,6 +372,110 @@ class InitialOutreachStage(BaseStage):
             'customextra': customextra
         }
 
+    def _schedule_initial_reminder_for_drafts(
+        self,
+        drafts: List[Dict[str, Any]],
+        customer_data: Dict[str, Any],
+        context: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Schedule reminder_task row for the highest-ranked draft after draft generation.
+
+        Mirrors the server-side behaviour where schedule_auto_run seeds reminder_task
+        so RealTimeX automations can pick up pending outreach immediately.
+        """
+        if not drafts:
+            return None
+
+        input_data = context.get('input_data', {})
+
+        if input_data.get('send_immediately'):
+            self.logger.debug("Skipping reminder scheduling because send_immediately is True")
+            return None
+
+        contact_info = customer_data.get('primaryContact', {}) or {}
+
+        recipient_address = (
+            input_data.get('recipient_address')
+            or contact_info.get('email')
+            or contact_info.get('emailAddress')
+        )
+        if not recipient_address:
+            self.logger.info("Skipping reminder scheduling: recipient email not available")
+            return None
+
+        recipient_name = (
+            input_data.get('recipient_name')
+            or contact_info.get('name')
+            or contact_info.get('fullName')
+            or ''
+        )
+
+        def _draft_sort_key(draft: Dict[str, Any]) -> tuple[int, float]:
+            priority = draft.get('priority_order')
+            if not isinstance(priority, int):
+                priority = 999
+            personalization = draft.get('personalization_score', 0)
+            try:
+                personalization_value = float(personalization)
+            except (TypeError, ValueError):
+                personalization_value = 0.0
+            return (priority, -personalization_value)
+
+        ordered_drafts = sorted(drafts, key=_draft_sort_key)
+        if not ordered_drafts:
+            return None
+
+        top_draft = ordered_drafts[0]
+
+        try:
+            from ..utils.event_scheduler import EventScheduler
+            scheduler = EventScheduler(self.config.get('data_dir', './fusesell_data'))
+        except Exception as exc:
+            self.logger.warning(
+                "Failed to initialise EventScheduler for reminder scheduling: %s",
+                exc
+            )
+            return {'success': False, 'error': str(exc)}
+
+        reminder_context = self._build_initial_reminder_context(
+            top_draft,
+            recipient_address,
+            recipient_name,
+            context
+        )
+
+        try:
+            schedule_result = scheduler.schedule_email_event(
+                draft_id=top_draft.get('draft_id'),
+                recipient_address=recipient_address,
+                recipient_name=recipient_name,
+                org_id=input_data.get('org_id') or self.config.get('org_id', 'default'),
+                team_id=input_data.get('team_id') or self.config.get('team_id'),
+                customer_timezone=input_data.get('customer_timezone'),
+                email_type='initial',
+                send_immediately=False,
+                reminder_context=reminder_context
+            )
+        except Exception as exc:
+            self.logger.error(f"Initial reminder scheduling failed: {exc}")
+            return {'success': False, 'error': str(exc)}
+
+        if schedule_result.get('success'):
+            self.logger.info(
+                "Scheduled initial outreach reminder %s for draft %s",
+                schedule_result.get('reminder_task_id'),
+                top_draft.get('draft_id')
+            )
+        else:
+            self.logger.warning(
+                "Reminder scheduling returned failure for draft %s: %s",
+                top_draft.get('draft_id'),
+                schedule_result.get('error')
+            )
+
+        return schedule_result
+
     def _handle_close(self, context: Dict[str, Any]) -> Dict[str, Any]:
         """
         Handle close action - Close outreach when customer feels negative.

{fusesell-1.2.5 → fusesell-1.2.6}/fusesell_local/utils/data_manager.py

@@ -3,14 +3,15 @@ Local Data Manager for FuseSell Local Implementation
 Handles SQLite database operations and local file management
 """
 
-import sqlite3
+import sqlite3
 import json
 import os
 import uuid
+import shutil
 from typing import Dict, Any, List, Optional, Sequence, Union
-from datetime import datetime
-import logging
-from pathlib import Path
+from datetime import datetime
+import logging
+from pathlib import Path
 
 
 class LocalDataManager:
@@ -69,10 +70,72 @@ class LocalDataManager:
         # Initialize database with optimization check
         self._init_database_optimized()
 
-    def _create_directories(self) -> None:
-        """Create necessary directories for data storage."""
-        for directory in [self.data_dir, self.config_dir, self.drafts_dir, self.logs_dir]:
-            directory.mkdir(parents=True, exist_ok=True)
+    def _create_directories(self) -> None:
+        """Create necessary directories for data storage."""
+        for directory in [self.data_dir, self.config_dir, self.drafts_dir, self.logs_dir]:
+            directory.mkdir(parents=True, exist_ok=True)
+        self._ensure_default_config_files()
+
+    def _ensure_default_config_files(self) -> None:
+        """
+        Copy bundled configuration defaults into the writable data directory when missing.
+
+        Ensures first-run executions always have the same baseline prompts, scoring criteria,
+        and email templates as the packaged FuseSell server flows.
+        """
+        try:
+            package_config_dir = Path(__file__).resolve().parents[2] / "fusesell_data" / "config"
+        except Exception as exc:
+            self.logger.debug(f"Unable to resolve packaged config directory: {exc}")
+            return
+
+        if not package_config_dir.exists():
+            self.logger.debug("Packaged config directory not found; skipping default config seeding")
+            return
+
+        default_files = [
+            "prompts.json",
+            "scoring_criteria.json",
+            "email_templates.json",
+        ]
+
+        for filename in default_files:
+            target = self.config_dir / filename
+            if target.exists():
+                continue
+
+            source = package_config_dir / filename
+            if not source.exists():
+                self.logger.debug(f"Packaged default {filename} not found; skipping seed")
+                continue
+
+            try:
+                shutil.copyfile(source, target)
+                self.logger.info(f"Seeded default configuration file: {filename}")
+            except Exception as exc:
+                self.logger.warning(f"Failed to seed default configuration {filename}: {exc}")
+
+    def _load_packaged_config_file(self, filename: str) -> Dict[str, Any]:
+        """
+        Load a configuration JSON file bundled with the package as a fallback.
+
+        Args:
+            filename: Name of the configuration file to load.
+
+        Returns:
+            Parsed configuration dictionary or empty dict on failure.
+        """
+        try:
+            package_config_dir = Path(__file__).resolve().parents[2] / "fusesell_data" / "config"
+            path = package_config_dir / filename
+            if not path.exists():
+                return {}
+
+            with path.open("r", encoding="utf-8") as handle:
+                return json.load(handle)
+        except Exception as exc:
+            self.logger.debug(f"Failed to load packaged config {filename}: {exc}")
+            return {}
 
     def _init_database_optimized(self) -> None:
         """
@@ -1050,56 +1113,71 @@ class LocalDataManager:
             self.logger.error(f"Failed to get stage results: {str(e)}")
             raise
 
-    def load_prompts(self) -> Dict[str, Any]:
-        """
-        Load prompt templates from configuration.
-
-        Returns:
-            Dictionary of prompt templates
-        """
-        try:
-            prompts_file = self.config_dir / "prompts.json"
-            if prompts_file.exists():
-                with open(prompts_file, 'r', encoding='utf-8') as f:
-                    return json.load(f)
-            return {}
-        except Exception as e:
-            self.logger.error(f"Failed to load prompts: {str(e)}")
-            return {}
-
-    def load_scoring_criteria(self) -> Dict[str, Any]:
+    def load_prompts(self) -> Dict[str, Any]:
+        """
+        Load prompt templates from configuration.
+
+        Returns:
+            Dictionary of prompt templates
+        """
+        try:
+            prompts_file = self.config_dir / "prompts.json"
+            if prompts_file.exists():
+                with open(prompts_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+
+            packaged = self._load_packaged_config_file("prompts.json")
+            if packaged:
+                return packaged
+
+            return {}
+        except Exception as e:
+            self.logger.error(f"Failed to load prompts: {str(e)}")
+            return {}
+
+    def load_scoring_criteria(self) -> Dict[str, Any]:
         """
         Load scoring criteria configuration.
 
-        Returns:
-            Dictionary of scoring criteria
-        """
-        try:
-            criteria_file = self.config_dir / "scoring_criteria.json"
-            if criteria_file.exists():
-                with open(criteria_file, 'r', encoding='utf-8') as f:
-                    return json.load(f)
-            return {}
-        except Exception as e:
-            self.logger.error(f"Failed to load scoring criteria: {str(e)}")
-            return {}
-
-    def load_email_templates(self) -> Dict[str, Any]:
+        Returns:
+            Dictionary of scoring criteria
+        """
+        try:
+            criteria_file = self.config_dir / "scoring_criteria.json"
+            if criteria_file.exists():
+                with open(criteria_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+
+            packaged = self._load_packaged_config_file("scoring_criteria.json")
+            if packaged:
+                return packaged
+
+            return {}
+        except Exception as e:
+            self.logger.error(f"Failed to load scoring criteria: {str(e)}")
+            return {}
+
+    def load_email_templates(self) -> Dict[str, Any]:
         """
         Load email templates configuration.
 
-        Returns:
-            Dictionary of email templates
-        """
-        try:
-            templates_file = self.config_dir / "email_templates.json"
-            if templates_file.exists():
-                with open(templates_file, 'r', encoding='utf-8') as f:
-                    return json.load(f)
-            return {}
-        except Exception as e:
-            self.logger.error(f"Failed to load email templates: {str(e)}")
-            return {}
+        Returns:
+            Dictionary of email templates
+        """
+        try:
+            templates_file = self.config_dir / "email_templates.json"
+            if templates_file.exists():
+                with open(templates_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+
+            packaged = self._load_packaged_config_file("email_templates.json")
+            if packaged:
+                return packaged
+
+            return {}
+        except Exception as e:
+            self.logger.error(f"Failed to load email templates: {str(e)}")
+            return {}
 
     def _generate_customer_id(self) -> str:
         """Generate unique customer ID."""

{fusesell-1.2.5 → fusesell-1.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fusesell"
-version = "1.2.5"
+version = "1.2.6"
 description = "Local implementation of FuseSell AI sales automation pipeline"
 readme = "README.md"
 license = "MIT"