fusesell 1.2.2__tar.gz → 1.2.3__tar.gz

{fusesell-1.2.2 → fusesell-1.2.3}/CHANGELOG.md

@@ -1,7 +1,18 @@
-# Changelog
-
+# Changelog
+
 All notable changes to FuseSell Local will be documented in this file.
 
+# [1.2.3] - 2025-10-21
+
+### Added
+- `LocalDataManager.search_products()` for server-compatible product filtering (status, keyword, limit, sort).
+- CLI `product list` flags and `list_products.py` filters wired to the new search helper.
+- Regression tests covering keyword search, sorting, and limiting behavior.
+
+### Changed
+- `get_products_by_org` now delegates to the filtered search path to avoid loading inactive results.
+- Product management documentation updated for RealTimeX flows and CLI filter usage.
+
 # [1.2.2] - 2025-10-21
 
 ### Added

{fusesell-1.2.2/fusesell.egg-info → fusesell-1.2.3}/PKG-INFO

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

{fusesell-1.2.2 → fusesell-1.2.3/fusesell.egg-info}/PKG-INFO

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

{fusesell-1.2.2 → fusesell-1.2.3}/fusesell_local/__init__.py

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

{fusesell-1.2.2 → fusesell-1.2.3}/fusesell_local/cli.py

@@ -410,11 +410,32 @@ Examples:
         update_parser.add_argument(
             '--subcategory', help='New product subcategory')
 
-        # Product list
-        list_parser = product_subparsers.add_parser(
-            'list', help='List products')
-        list_parser.add_argument(
-            '--org-id', required=True, help='Organization ID')
+        # Product list
+        list_parser = product_subparsers.add_parser(
+            'list', help='List products')
+        list_parser.add_argument(
+            '--org-id', required=True, help='Organization ID')
+        list_parser.add_argument(
+            '--status',
+            choices=['active', 'inactive', 'all'],
+            default='active',
+            help='Filter products by status (default: active)',
+        )
+        list_parser.add_argument(
+            '--search-term',
+            help='Keyword to match against product name or descriptions',
+        )
+        list_parser.add_argument(
+            '--limit',
+            type=int,
+            help='Maximum number of products to return',
+        )
+        list_parser.add_argument(
+            '--sort',
+            choices=['name', 'created_at', 'updated_at'],
+            default='name',
+            help='Sort order for results (default: name)',
+        )
 
     def _add_settings_arguments(self, parser: argparse.ArgumentParser) -> None:
         """Add settings management arguments."""
@@ -1029,13 +1050,19 @@ Examples:
                         f"Product not found: {args.product_id}", file=sys.stderr)
                     return 1
 
-            elif action == 'list':
-                products = data_manager.get_products_by_org(args.org_id)
-                if products:
-                    print(f"Products for organization {args.org_id}:")
-                    for product in products:
-                        print(
-                            f"  {product['product_id']}: {product['product_name']} - {product.get('short_description', 'No description')}")
+            elif action == 'list':
+                products = data_manager.search_products(
+                    org_id=args.org_id,
+                    status=getattr(args, 'status', 'active'),
+                    search_term=getattr(args, 'search_term', None),
+                    limit=getattr(args, 'limit', None),
+                    sort=getattr(args, 'sort', 'name'),
+                )
+                if products:
+                    print(f"Products for organization {args.org_id}:")
+                    for product in products:
+                        print(
+                            f"  {product['product_id']}: {product['product_name']} - {product.get('short_description', 'No description')}")
                 else:
                     print(f"No products found for organization {args.org_id}")
                 return 0

{fusesell-1.2.2 → fusesell-1.2.3}/fusesell_local/tests/test_data_manager_products.py

@@ -71,4 +71,70 @@ def test_get_products_by_org_returns_active_products_only(data_manager):
 
     results = data_manager.get_products_by_org(active["org_id"])
     assert len(results) == 1
-    assert results[0]["product_id"] == active["product_id"]
+    assert results[0]["product_id"] == active["product_id"]
+
+
+def test_search_products_filters_by_keyword(data_manager):
+    alpha = _sample_product_payload(
+        "prod-alpha",
+        productName="Alpha CRM",
+        shortDescription="CRM automation platform",
+        keywords=["CRM", "pipeline"],
+    )
+    beta = _sample_product_payload(
+        "prod-beta",
+        productName="Beta Ops",
+        shortDescription="Operations toolkit",
+        keywords=["ops"],
+    )
+
+    data_manager.save_product(alpha)
+    data_manager.save_product(beta)
+
+    results = data_manager.search_products(
+        org_id="org-123",
+        search_term="crm",
+    )
+
+    assert len(results) == 1
+    assert results[0]["product_id"] == "prod-alpha"
+
+
+def test_search_products_limit_and_sort(data_manager):
+    first = _sample_product_payload("prod-c", productName="Charlie Suite")
+    second = _sample_product_payload("prod-a", productName="Alpha Suite")
+    third = _sample_product_payload("prod-b", productName="Bravo Suite")
+
+    data_manager.save_product(first)
+    data_manager.save_product(second)
+    data_manager.save_product(third)
+
+    # Update timestamps to control order
+    with sqlite3.connect(data_manager.db_path) as conn:
+        conn.execute(
+            "UPDATE products SET updated_at = ? WHERE product_id = ?",
+            ("2024-01-01 10:00:00", "prod-a"),
+        )
+        conn.execute(
+            "UPDATE products SET updated_at = ? WHERE product_id = ?",
+            ("2024-01-02 10:00:00", "prod-b"),
+        )
+        conn.execute(
+            "UPDATE products SET updated_at = ? WHERE product_id = ?",
+            ("2024-01-03 10:00:00", "prod-c"),
+        )
+        conn.commit()
+
+    by_name = data_manager.search_products(
+        org_id="org-123",
+        sort="name",
+        limit=2,
+    )
+    assert [p["product_id"] for p in by_name] == ["prod-a", "prod-b"]
+
+    by_updated = data_manager.search_products(
+        org_id="org-123",
+        sort="updated_at",
+        limit=2,
+    )
+    assert [p["product_id"] for p in by_updated] == ["prod-c", "prod-b"]

{fusesell-1.2.2 → fusesell-1.2.3}/fusesell_local/utils/data_manager.py

@@ -13,15 +13,40 @@ import logging
 from pathlib import Path
 
 
-class LocalDataManager:
-    """
-    Manages local data storage using SQLite database and JSON files.
-    Provides interface for storing execution results, customer data, and configurations.
-    """
-    
-    # Class-level tracking to prevent multiple initializations
-    _initialized_databases = set()
-    _initialization_lock = False
+class LocalDataManager:
+    """
+    Manages local data storage using SQLite database and JSON files.
+    Provides interface for storing execution results, customer data, and configurations.
+    """
+    
+    # Class-level tracking to prevent multiple initializations
+    _initialized_databases = set()
+    _initialization_lock = False
+    _product_json_fields = [
+        'target_users',
+        'key_features',
+        'unique_selling_points',
+        'pain_points_solved',
+        'competitive_advantages',
+        'pricing',
+        'pricing_rules',
+        'sales_metrics',
+        'customer_feedback',
+        'keywords',
+        'related_products',
+        'seasonal_demand',
+        'market_insights',
+        'case_studies',
+        'testimonials',
+        'success_metrics',
+        'product_variants',
+        'technical_specifications',
+        'compatibility',
+        'support_info',
+        'regulatory_compliance',
+        'localization',
+        'shipping_info'
+    ]
 
     def __init__(self, data_dir: str = "./fusesell_data"):
         """
@@ -1342,50 +1367,72 @@ class LocalDataManager:
             self.logger.error(f"Failed to save team settings: {str(e)}")
             raise
 
-    def get_team_settings(self, team_id: str) -> Optional[Dict[str, Any]]:
-        """
-        Get team settings by team ID.
-
-        Args:
-            team_id: Team identifier
-
-        Returns:
-            Team settings dictionary or None if not found
-        """
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                conn.row_factory = sqlite3.Row
-                cursor = conn.cursor()
-                cursor.execute(
-                    "SELECT * FROM team_settings WHERE team_id = ?", (team_id,))
-                row = cursor.fetchone()
-
-                if row:
-                    result = dict(row)
-                    # Parse JSON fields
-                    json_fields = [
-                        'gs_team_organization', 'gs_team_rep', 'gs_team_product',
-                        'gs_team_schedule_time', 'gs_team_initial_outreach', 'gs_team_follow_up',
-                        'gs_team_auto_interaction', 'gs_team_followup_schedule_time', 'gs_team_birthday_email'
-                    ]
-
-                    for field in json_fields:
-                        if result[field]:
-                            try:
-                                result[field] = json.loads(result[field])
-                            except json.JSONDecodeError:
-                                result[field] = None
-
-                    return result
-                return None
-
-        except Exception as e:
-            self.logger.error(f"Failed to get team settings: {str(e)}")
-            raise
-
-    def save_product(self, product_data: Dict[str, Any]) -> str:
-        """
-        Save or update product information.
+    def get_team_settings(self, team_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get team settings by team ID.
+
+        Args:
+            team_id: Team identifier
+
+        Returns:
+            Team settings dictionary or None if not found
+        """
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                conn.row_factory = sqlite3.Row
+                cursor = conn.cursor()
+                cursor.execute(
+                    "SELECT * FROM team_settings WHERE team_id = ?", (team_id,))
+                row = cursor.fetchone()
+
+                if row:
+                    result = dict(row)
+                    # Parse JSON fields
+                    json_fields = [
+                        'gs_team_organization', 'gs_team_rep', 'gs_team_product',
+                        'gs_team_schedule_time', 'gs_team_initial_outreach', 'gs_team_follow_up',
+                        'gs_team_auto_interaction', 'gs_team_followup_schedule_time', 'gs_team_birthday_email'
+                    ]
+
+                    for field in json_fields:
+                        if result[field]:
+                            try:
+                                result[field] = json.loads(result[field])
+                            except json.JSONDecodeError:
+                                result[field] = None
+
+                    return result
+                return None
+
+        except Exception as e:
+            self.logger.error(f"Failed to get team settings: {str(e)}")
+            raise
+
+    def _deserialize_product_row(self, row: sqlite3.Row) -> Dict[str, Any]:
+        """
+        Convert a product row into a dictionary with JSON fields parsed.
+
+        Args:
+            row: SQLite row containing product data
+
+        Returns:
+            Dictionary representation of the row with JSON fields decoded
+        """
+        product = dict(row)
+
+        for field in self._product_json_fields:
+            value = product.get(field)
+            if value:
+                try:
+                    product[field] = json.loads(value)
+                except (json.JSONDecodeError, TypeError):
+                    product[field] = None
+
+        return product
+
+    def save_product(self, product_data: Dict[str, Any]) -> str:
+        """
+        Save or update product information.
 
         Args:
             product_data: Product information dictionary
@@ -1569,50 +1616,119 @@ class LocalDataManager:
             self.logger.error(f"Failed to save product: {str(e)}")
             raise
 
-    def get_products_by_org(self, org_id: str) -> List[Dict[str, Any]]:
-        """
-        Get all products for an organization.
-
-        Args:
-            org_id: Organization identifier
-
-        Returns:
-            List of product dictionaries
-        """
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                conn.row_factory = sqlite3.Row
-                cursor = conn.cursor()
-                cursor.execute(
-                    "SELECT * FROM products WHERE org_id = ? AND status = 'active'", (org_id,))
-
-                products = []
-                for row in cursor.fetchall():
-                    product = dict(row)
-                    # Parse JSON fields
-                    json_fields = [
-                        'target_users', 'key_features', 'unique_selling_points', 'pain_points_solved',
-                        'competitive_advantages', 'pricing', 'pricing_rules', 'sales_metrics',
-                        'customer_feedback', 'keywords', 'related_products', 'seasonal_demand',
-                        'market_insights', 'case_studies', 'testimonials', 'success_metrics',
-                        'product_variants', 'technical_specifications', 'compatibility', 'support_info',
-                        'regulatory_compliance', 'localization', 'shipping_info'
-                    ]
-
-                    for field in json_fields:
-                        if product[field]:
-                            try:
-                                product[field] = json.loads(product[field])
-                            except json.JSONDecodeError:
-                                product[field] = None
-
-                    products.append(product)
-
-                return products
-
-        except Exception as e:
-            self.logger.error(f"Failed to get products: {str(e)}")
-            raise
+    def search_products(
+        self,
+        org_id: str,
+        status: Optional[str] = "active",
+        search_term: Optional[str] = None,
+        limit: Optional[int] = None,
+        sort: Optional[str] = "name"
+    ) -> List[Dict[str, Any]]:
+        """
+        Search products for an organization with optional filters.
+
+        Args:
+            org_id: Organization identifier
+            status: Product status filter ("active", "inactive", or "all")
+            search_term: Keyword to match against name, descriptions, or keywords
+            limit: Maximum number of products to return
+            sort: Sort order ("name", "created_at", "updated_at")
+
+        Returns:
+            List of product dictionaries
+        """
+        try:
+            def _is_placeholder(value: Any) -> bool:
+                return isinstance(value, str) and value.strip().startswith("{{") and value.strip().endswith("}}")
+
+            # Normalize status
+            normalized_status: Optional[str] = status
+            if _is_placeholder(normalized_status):
+                normalized_status = None
+            if isinstance(normalized_status, str):
+                normalized_status = normalized_status.strip().lower()
+            if normalized_status not in {'active', 'inactive', 'all'}:
+                normalized_status = 'active'
+
+            # Normalize sort
+            normalized_sort: Optional[str] = sort
+            if _is_placeholder(normalized_sort):
+                normalized_sort = None
+            if isinstance(normalized_sort, str):
+                normalized_sort = normalized_sort.strip().lower()
+            sort_map = {
+                'name': ("product_name COLLATE NOCASE", "ASC"),
+                'created_at': ("datetime(created_at)", "DESC"),
+                'updated_at': ("datetime(updated_at)", "DESC"),
+            }
+            order_by, direction = sort_map.get(normalized_sort, sort_map['name'])
+
+            # Normalize search term
+            normalized_search: Optional[str] = None
+            if not _is_placeholder(search_term) and search_term is not None:
+                normalized_search = str(search_term).strip()
+            if normalized_search == "":
+                normalized_search = None
+
+            # Normalize limit
+            normalized_limit: Optional[int] = None
+            if not _is_placeholder(limit) and limit is not None:
+                try:
+                    normalized_limit = int(limit)
+                    if normalized_limit <= 0:
+                        normalized_limit = None
+                except (TypeError, ValueError):
+                    normalized_limit = None
+
+            where_clauses = ["org_id = ?"]
+            params: List[Any] = [org_id]
+
+            if normalized_status != 'all':
+                where_clauses.append("status = ?")
+                params.append(normalized_status)
+
+            query = "SELECT * FROM products WHERE " + " AND ".join(where_clauses)
+
+            if normalized_search:
+                like_value = f"%{normalized_search.lower()}%"
+                query += (
+                    " AND ("
+                    "LOWER(product_name) LIKE ? OR "
+                    "LOWER(COALESCE(short_description, '')) LIKE ? OR "
+                    "LOWER(COALESCE(long_description, '')) LIKE ? OR "
+                    "LOWER(COALESCE(keywords, '')) LIKE ?)"
+                )
+                params.extend([like_value] * 4)
+
+            query += f" ORDER BY {order_by} {direction}"
+
+            if normalized_limit is not None:
+                query += " LIMIT ?"
+                params.append(normalized_limit)
+
+            with sqlite3.connect(self.db_path) as conn:
+                conn.row_factory = sqlite3.Row
+                cursor = conn.cursor()
+                cursor.execute(query, params)
+                rows = cursor.fetchall()
+
+            return [self._deserialize_product_row(row) for row in rows]
+
+        except Exception as e:
+            self.logger.error(f"Failed to search products: {str(e)}")
+            raise
+
+    def get_products_by_org(self, org_id: str) -> List[Dict[str, Any]]:
+        """
+        Backward-compatible helper that returns active products for an organization.
+
+        Args:
+            org_id: Organization identifier
+
+        Returns:
+            List of active product dictionaries
+        """
+        return self.search_products(org_id=org_id, status="active")
 
     def get_products_by_team(self, team_id: str) -> List[Dict[str, Any]]:
         """
@@ -1649,34 +1765,13 @@ class LocalDataManager:
                 cursor.execute(
                     f"SELECT * FROM products WHERE product_id IN ({placeholders}) AND status = 'active'", product_ids)
 
-                products = []
-                for row in cursor.fetchall():
-                    product = dict(row)
-                    # Parse JSON fields (same as get_products_by_org)
-                    json_fields = [
-                        'target_users', 'key_features', 'unique_selling_points', 'pain_points_solved',
-                        'competitive_advantages', 'pricing', 'pricing_rules', 'sales_metrics',
-                        'customer_feedback', 'keywords', 'related_products', 'seasonal_demand',
-                        'market_insights', 'case_studies', 'testimonials', 'success_metrics',
-                        'product_variants', 'technical_specifications', 'compatibility', 'support_info',
-                        'regulatory_compliance', 'localization', 'shipping_info'
-                    ]
-
-                    for field in json_fields:
-                        if product[field]:
-                            try:
-                                product[field] = json.loads(product[field])
-                            except json.JSONDecodeError:
-                                product[field] = None
-
-                    products.append(product)
-
-                return products
-
-        except Exception as e:
-            self.logger.error(f"Failed to get products by team: {str(e)}")
-            raise
-
+                return [self._deserialize_product_row(row)
+                        for row in cursor.fetchall()]
+
+        except Exception as e:
+            self.logger.error(f"Failed to get products by team: {str(e)}")
+            raise
+
     def get_product(self, product_id: str) -> Optional[Dict[str, Any]]:
         """
         Get product by ID.
@@ -1692,33 +1787,15 @@ class LocalDataManager:
                 conn.row_factory = sqlite3.Row
                 cursor = conn.cursor()
                 cursor.execute("SELECT * FROM products WHERE product_id = ?", (product_id,))
-                row = cursor.fetchone()
-
-                if row:
-                    product = dict(row)
-                    # Parse JSON fields
-                    json_fields = [
-                        'target_users', 'key_features', 'unique_selling_points', 'pain_points_solved',
-                        'competitive_advantages', 'pricing', 'pricing_rules', 'sales_metrics',
-                        'customer_feedback', 'keywords', 'related_products', 'seasonal_demand',
-                        'market_insights', 'case_studies', 'testimonials', 'success_metrics',
-                        'product_variants', 'technical_specifications', 'compatibility', 'support_info',
-                        'regulatory_compliance', 'localization', 'shipping_info'
-                    ]
-
-                    for field in json_fields:
-                        if product[field]:
-                            try:
-                                product[field] = json.loads(product[field])
-                            except json.JSONDecodeError:
-                                product[field] = None
-
-                    return product
-                return None
-
-        except Exception as e:
-            self.logger.error(f"Error getting product {product_id}: {str(e)}")
-            raise
+                row = cursor.fetchone()
+
+                if row:
+                    return self._deserialize_product_row(row)
+                return None
+
+        except Exception as e:
+            self.logger.error(f"Error getting product {product_id}: {str(e)}")
+            raise
 
     def update_product(self, product_id: str, product_data: Dict[str, Any]) -> bool:
         """

{fusesell-1.2.2 → fusesell-1.2.3}/pyproject.toml

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