fusesell 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

{fusesell-1.2.2.dist-info → fusesell-1.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fusesell
-Version: 1.2.2
+Version: 1.2.4
 Summary: Local implementation of FuseSell AI sales automation pipeline
 Author-email: FuseSell Team <team@fusesell.ai>
 License-Expression: MIT
@@ -45,7 +45,9 @@ Dynamic: license-file
 
 FuseSell Local is a production-ready implementation of the FuseSell AI sales automation system, converted from server-based YAML workflows to a comprehensive Python command-line tool with full data ownership and privacy control.
 
-> Latest release: `fusesell==1.2.1` is available on PyPI via `pip install fusesell`.
+Latest release: `fusesell==1.2.1` is available on PyPI via `pip install fusesell`.
+
+Contributors should review the [Repository Guidelines](AGENTS.md) before opening a pull request.
 
 ## 🚀 Complete Pipeline Overview
 

{fusesell-1.2.2.dist-info → fusesell-1.2.4.dist-info}/RECORD

@@ -1,8 +1,8 @@
 fusesell.py,sha256=t5PjkhWEJGINp4k517u0EX0ge7lzuHOUHHro-BE1mGk,596
-fusesell-1.2.2.dist-info/licenses/LICENSE,sha256=GDz1ZoC4lB0kwjERpzqc_OdA_awYVso2aBnUH-ErW_w,1070
-fusesell_local/__init__.py,sha256=GmgCJXR8YDix18M51v04I2sh6EI9Z6H8tlXqyZzhs_c,966
+fusesell-1.2.4.dist-info/licenses/LICENSE,sha256=GDz1ZoC4lB0kwjERpzqc_OdA_awYVso2aBnUH-ErW_w,1070
+fusesell_local/__init__.py,sha256=5kIksTuzPSk57Yq7vqJC3pFHs9ZOyxaGSkA9QxqzEq0,966
 fusesell_local/api.py,sha256=AcPune5YJdgi7nsMeusCUqc49z5UiycsQb6n3yiV_No,10839
-fusesell_local/cli.py,sha256=l9ZjiRJpYCjFfSLmTvxRs8XhB6TqRPkeqbFZsM2xP5o,64870
+fusesell_local/cli.py,sha256=MYnVxuEf5KTR4VcO3sc-VtP9NkWlSixJsYfOWST2Ds0,65859
 fusesell_local/pipeline.py,sha256=KO5oAIHZ3L_uAZWOszauJyv0QWlsQMIDNGRuwQSxNmQ,39531
 fusesell_local/config/__init__.py,sha256=0ErO7QiSDqKn-LHcjIRdLZzh5QaRTkRsIlwfgpkkDz8,209
 fusesell_local/config/prompts.py,sha256=5O3Y2v3GCi9d9FEyR6Ekc1UXVq2TcZp3Rrspvx4bkac,10164
@@ -17,19 +17,19 @@ fusesell_local/stages/lead_scoring.py,sha256=ir3l849eMGrGLf0OYUcmA1F3FwyYhAplS4n
 fusesell_local/tests/conftest.py,sha256=TWUtlP6cNPVOYkTPz-j9BzS_KnXdPWy8D-ObPLHvXYs,366
 fusesell_local/tests/test_api.py,sha256=763rUVb5pAuAQOovug6Ka0T9eGK8-WVOC_J08M7TETo,1827
 fusesell_local/tests/test_cli.py,sha256=iNgU8nDlVrcQM5MpBUTIJ5q3oh2-jgX77hJeaqBxToM,1007
-fusesell_local/tests/test_data_manager_products.py,sha256=V88N6NEmaa-o84-aReh2lKDGteB76wwTCg_xM6da3kQ,2669
+fusesell_local/tests/test_data_manager_products.py,sha256=g8EUSxTqdg18VifzhuOtDDywiMYzwOWFADny5Vntc28,4691
 fusesell_local/tests/test_data_manager_sales_process.py,sha256=NbwxQ9oBKCZfrkRQYxzHHQ08F7epqPUsyeGz_vm3kf8,4447
 fusesell_local/tests/test_data_manager_teams.py,sha256=kjk4V4r9ja4EVREIiQMxkuZd470SSwRHJAvpHln9KO4,4578
 fusesell_local/utils/__init__.py,sha256=TVemlo0wpckhNUxP3a1Tky3ekswy8JdIHaXBlkKXKBQ,330
 fusesell_local/utils/birthday_email_manager.py,sha256=NKLoUyzPedyhewZPma21SOoU8p9wPquehloer7TRA9U,20478
-fusesell_local/utils/data_manager.py,sha256=68ECkZ6fN9Ccc_Me7yh-qGB6tl32TSm4GB058SE0C94,176793
+fusesell_local/utils/data_manager.py,sha256=MVozSojGXbIr9mhaTIt5bQrFO_1o-4BJux03FPW0jxA,180881
 fusesell_local/utils/event_scheduler.py,sha256=rjtWwtYQoJP0YwoN1-43t6K9GpLfqRq3c7Fv4papvbI,25725
 fusesell_local/utils/llm_client.py,sha256=FVc25UlGt6hro7h5Iw7PHSXY3E3_67Xc-SUbHuMSRs0,10437
 fusesell_local/utils/logger.py,sha256=sWlV8Tjyz_Z8J4zXKOnNalh8_iD6ytfrwPZpD-wcEOs,6259
 fusesell_local/utils/timezone_detector.py,sha256=0cAE4c8ZXqCA8AvxRKm6PrFKmAmsbq3HOHR6w-mW3KQ,39997
 fusesell_local/utils/validators.py,sha256=Z1VzeoxFsnuzlIA_ZaMWoy-0Cgyqupd47kIdljlMDbs,15438
-fusesell-1.2.2.dist-info/METADATA,sha256=ASCu2jnknl2Oz7BvqtQMmIGAXpQAOQKH6E8ia9GbSaw,34976
-fusesell-1.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fusesell-1.2.2.dist-info/entry_points.txt,sha256=Vqek7tbiX7iF4rQkCRBZvT5WrB0HUduqKTsI2ZjhsXo,53
-fusesell-1.2.2.dist-info/top_level.txt,sha256=VP9y1K6DEq6gNq2UgLd7ChujxViF6OzeAVCK7IUBXPA,24
-fusesell-1.2.2.dist-info/RECORD,,
+fusesell-1.2.4.dist-info/METADATA,sha256=cBzLD9FHG3yQu300mnPm48TKgNH1adgcF66gIF9vqHk,35074
+fusesell-1.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fusesell-1.2.4.dist-info/entry_points.txt,sha256=Vqek7tbiX7iF4rQkCRBZvT5WrB0HUduqKTsI2ZjhsXo,53
+fusesell-1.2.4.dist-info/top_level.txt,sha256=VP9y1K6DEq6gNq2UgLd7ChujxViF6OzeAVCK7IUBXPA,24
+fusesell-1.2.4.dist-info/RECORD,,

fusesell_local/__init__.py

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

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_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_local/utils/data_manager.py

@@ -4,24 +4,49 @@ Handles SQLite database operations and local file management
 """
 
 import sqlite3
-import json
-import os
-import uuid
-from typing import Dict, Any, List, Optional, Union
+import json
+import os
+import uuid
+from typing import Dict, Any, List, Optional, Sequence, Union
 from datetime import datetime
 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,149 @@ 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 build_team_settings_snapshot(
+        self,
+        team_id: str,
+        sections: Optional[Sequence[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Build a response payload containing team settings in the expected RealTimeX format.
+
+        Args:
+            team_id: Team identifier
+            sections: Optional sequence of section names to include. Accepts either
+                full keys (e.g. ``gs_team_product``) or shorthand without the prefix.
+
+        Returns:
+            Dictionary shaped as ``{"data": [{...}]}``. When no settings exist,
+            returns ``{"data": []}``.
+        """
+        settings = self.get_team_settings(team_id)
+        if not settings:
+            return {"data": []}
+
+        available_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',
+        ]
+
+        if sections:
+            normalized = set()
+            for item in sections:
+                if not item:
+                    continue
+                item = item.strip()
+                if not item:
+                    continue
+                if item.startswith("gs_team_"):
+                    normalized.add(item)
+                else:
+                    normalized.add(f"gs_team_{item}")
+            fields_to_include = [field for field in available_fields if field in normalized]
+        else:
+            fields_to_include = available_fields
+
+        list_like_fields = {
+            'gs_team_organization',
+            'gs_team_rep',
+            'gs_team_product',
+            'gs_team_auto_interaction',
+        }
+
+        snapshot: Dict[str, Any] = {}
+        for field in fields_to_include:
+            value = settings.get(field)
+            if value is None:
+                continue
+
+            if field in list_like_fields:
+                if isinstance(value, list):
+                    snapshot[field] = value
+                elif value:
+                    snapshot[field] = [value]
+                else:
+                    snapshot[field] = []
+            else:
+                snapshot[field] = value
+
+        if not snapshot:
+            return {"data": []}
+
+        return {"data": [snapshot]}
+
+    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 +1693,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 +1842,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 +1864,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:
         """