fusesell 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

{fusesell-1.2.1.dist-info → fusesell-1.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fusesell
-Version: 1.2.1
+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.1.dist-info → fusesell-1.2.3.dist-info}/RECORD

@@ -1,8 +1,8 @@
 fusesell.py,sha256=t5PjkhWEJGINp4k517u0EX0ge7lzuHOUHHro-BE1mGk,596
-fusesell-1.2.1.dist-info/licenses/LICENSE,sha256=GDz1ZoC4lB0kwjERpzqc_OdA_awYVso2aBnUH-ErW_w,1070
-fusesell_local/__init__.py,sha256=zCkVbO68h1wbnV8owWjLdBqMK3F_gyFgrtRZICeU_KQ,967
+fusesell-1.2.3.dist-info/licenses/LICENSE,sha256=GDz1ZoC4lB0kwjERpzqc_OdA_awYVso2aBnUH-ErW_w,1070
+fusesell_local/__init__.py,sha256=fEvogPM4NPOiL4oLU9oK0HWECKyTvAGB4rSUr1XI-So,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
@@ -14,18 +14,22 @@ fusesell_local/stages/data_preparation.py,sha256=XWLg9b1w2NrMxLcrWDqB95mRmLQmVIM
 fusesell_local/stages/follow_up.py,sha256=2CSen5SHJ5k6KMHXpqoRBb3n3IrcMRdDnuyTsOeuRTA,74625
 fusesell_local/stages/initial_outreach.py,sha256=jox2caveSwI3xIfjn8FGYprkjTbW8YhDNvCzz9wNcBE,107503
 fusesell_local/stages/lead_scoring.py,sha256=ir3l849eMGrGLf0OYUcmA1F3FwyYhAplS4niU3R2GRY,60658
+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=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=wMP0fGeFVCEVOl6QOu2lXvzGqfW3apn_H3Fl7vy11lE,175558
+fusesell_local/utils/data_manager.py,sha256=w2Ed0HAdkTg23r_Fz_v8j3H_jcXbgD_Xk_lfeySi9bk,178447
 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.1.dist-info/METADATA,sha256=BoUem4q6oYCj8oh_BnH42ihbeJLKRUESwWp-Ct0_Qfw,34976
-fusesell-1.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fusesell-1.2.1.dist-info/entry_points.txt,sha256=Vqek7tbiX7iF4rQkCRBZvT5WrB0HUduqKTsI2ZjhsXo,53
-fusesell-1.2.1.dist-info/top_level.txt,sha256=VP9y1K6DEq6gNq2UgLd7ChujxViF6OzeAVCK7IUBXPA,24
-fusesell-1.2.1.dist-info/RECORD,,
+fusesell-1.2.3.dist-info/METADATA,sha256=Izbft0CEbjY1O9NQebg5b6FxgMJpd8p24N8FDWE1e-o,34976
+fusesell-1.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fusesell-1.2.3.dist-info/entry_points.txt,sha256=Vqek7tbiX7iF4rQkCRBZvT5WrB0HUduqKTsI2ZjhsXo,53
+fusesell-1.2.3.dist-info/top_level.txt,sha256=VP9y1K6DEq6gNq2UgLd7ChujxViF6OzeAVCK7IUBXPA,24
+fusesell-1.2.3.dist-info/RECORD,,

fusesell_local/__init__.py

@@ -32,6 +32,6 @@ __all__ = [
     "validate_config",
 ]
 
-__version__ = "1.2.1"
+__version__ = "1.2.3"
 __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/conftest.py

@@ -0,0 +1,11 @@
+import pytest
+
+from fusesell_local.utils.data_manager import LocalDataManager
+
+
+@pytest.fixture
+def data_manager(tmp_path):
+    """Provide an isolated LocalDataManager instance backed by a temporary directory."""
+    LocalDataManager._initialized_databases.clear()
+    LocalDataManager._initialization_lock = False
+    return LocalDataManager(data_dir=str(tmp_path))

fusesell_local/tests/test_data_manager_products.py

@@ -0,0 +1,140 @@
+import sqlite3
+
+
+def _sample_product_payload(product_id: str = "prod-001", **overrides):
+    payload = {
+        "product_id": product_id,
+        "org_id": "org-123",
+        "org_name": "FuseSell Org",
+        "project_code": "proj-001",
+        "productName": "FuseSell AI Suite",
+        "shortDescription": "AI-powered sales automation",
+        "longDescription": "Comprehensive automation platform for revenue teams.",
+        "category": "Software",
+        "subcategory": "Sales Automation",
+        "targetUsers": ["Sales reps"],
+        "keyFeatures": ["Automation", "CRM sync"],
+        "uniqueSellingPoints": ["Privacy-first"],
+        "pricing": {"monthly": 199},
+        "pricingRules": {"currency": "USD"},
+        "productWebsite": "https://fusesell.test/ai-suite",
+    }
+    payload.update(overrides)
+    return payload
+
+
+def test_save_and_get_product_roundtrip(data_manager):
+    payload = _sample_product_payload()
+    product_id = data_manager.save_product(payload)
+
+    assert product_id == payload["product_id"]
+
+    stored = data_manager.get_product(product_id)
+    assert stored is not None
+    assert stored["product_name"] == payload["productName"]
+    assert stored["org_id"] == payload["org_id"]
+    assert stored["key_features"] == payload["keyFeatures"]
+    assert stored["pricing"] == payload["pricing"]
+
+
+def test_update_product_merges_changes(data_manager):
+    payload = _sample_product_payload()
+    product_id = data_manager.save_product(payload)
+
+    updated = {
+        "shortDescription": "Updated messaging",
+        "pricing": {"monthly": 249, "yearly": 2490},
+        "keyFeatures": ["Automation", "Analytics"],
+    }
+    assert data_manager.update_product(product_id, updated) is True
+
+    stored = data_manager.get_product(product_id)
+    assert stored["short_description"] == updated["shortDescription"]
+    assert stored["pricing"]["monthly"] == 249
+    assert stored["key_features"] == updated["keyFeatures"]
+
+
+def test_get_products_by_org_returns_active_products_only(data_manager):
+    active = _sample_product_payload("prod-active")
+    inactive = _sample_product_payload("prod-inactive")
+
+    data_manager.save_product(active)
+    data_manager.save_product(inactive)
+
+    # Mark one product inactive directly to exercise status filtering
+    with sqlite3.connect(data_manager.db_path) as conn:
+        conn.execute(
+            "UPDATE products SET status = 'inactive' WHERE product_id = ?",
+            (inactive["product_id"],),
+        )
+        conn.commit()
+
+    results = data_manager.get_products_by_org(active["org_id"])
+    assert len(results) == 1
+    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/tests/test_data_manager_sales_process.py

@@ -0,0 +1,115 @@
+def _create_task(data_manager, task_id: str, customer: str = "Acme Corp", status: str = "running"):
+    request_body = {"customer_info": customer, "org_name": "FuseSell Org"}
+    data_manager.create_task(
+        task_id=task_id,
+        plan_id="plan-456",
+        org_id="org-123",
+        request_body=request_body,
+        status=status,
+    )
+    return request_body
+
+
+def test_create_task_and_get_task_by_id(data_manager):
+    task_id = "task-001"
+    request_body = _create_task(data_manager, task_id)
+
+    record = data_manager.get_task_by_id(task_id)
+    assert record is not None
+    assert record["task_id"] == task_id
+    assert record["status"] == "running"
+    assert record["request_body"]["customer_info"] == request_body["customer_info"]
+    assert record["messages"] == []
+
+
+def test_update_task_status_tracks_runtime(data_manager):
+    task_id = "task-002"
+    _create_task(data_manager, task_id)
+
+    data_manager.update_task_status(task_id, "completed", runtime_index=4)
+
+    record = data_manager.get_task_by_id(task_id)
+    assert record["status"] == "completed"
+    assert record["current_runtime_index"] == 4
+
+
+def test_create_operation_and_update_status(data_manager):
+    task_id = "task-003"
+    _create_task(data_manager, task_id)
+
+    operation_id = data_manager.create_operation(
+        task_id, "gs_161_data_acquisition", runtime_index=0, chain_index=0, input_data={"step": 1}
+    )
+    operation = data_manager.get_operation(operation_id)
+    assert operation is not None
+    assert operation["execution_status"] == "running"
+    assert operation["input_data"]["step"] == 1
+
+    data_manager.update_operation_status(operation_id, "done", {"result": "ok"})
+    updated = data_manager.get_operation(operation_id)
+    assert updated["execution_status"] == "done"
+    assert updated["output_data"]["result"] == "ok"
+
+
+def test_get_task_with_operations_returns_summary(data_manager):
+    task_id = "task-ops"
+    _create_task(data_manager, task_id)
+
+    op_a = data_manager.create_operation(
+        task_id, "gs_161_data_acquisition", runtime_index=0, chain_index=0, input_data={"stage": "acquire"}
+    )
+    op_b = data_manager.create_operation(
+        task_id, "gs_161_data_preparation", runtime_index=0, chain_index=1, input_data={"stage": "prepare"}
+    )
+    data_manager.update_operation_status(op_a, "done", {"status": "ok"})
+    data_manager.update_operation_status(op_b, "running")
+
+    record = data_manager.get_task_with_operations(task_id)
+    assert record is not None
+    assert record["task_id"] == task_id
+    assert len(record["operations"]) == 2
+    assert record["summary"]["completed_operations"] == 1
+    assert record["summary"]["running_operations"] == 1
+
+
+def test_find_sales_processes_by_customer(data_manager):
+    task_acme = "task-acme"
+    task_beta = "task-beta"
+    _create_task(data_manager, task_acme, customer="Acme Corp")
+    _create_task(data_manager, task_beta, customer="Beta LLC")
+
+    results = data_manager.find_sales_processes_by_customer("Acme")
+    assert len(results) == 1
+    assert results[0]["task_id"] == task_acme
+    assert results[0]["request_body"]["customer_info"] == "Acme Corp"
+
+
+def test_list_tasks_filters_by_status(data_manager):
+    running_id = "task-running"
+    completed_id = "task-completed"
+    _create_task(data_manager, running_id, status="running")
+    _create_task(data_manager, completed_id, status="running")
+    data_manager.update_task_status(completed_id, "completed")
+
+    running_tasks = data_manager.list_tasks(status="running")
+    completed_tasks = data_manager.list_tasks(status="completed")
+
+    assert {task["task_id"] for task in running_tasks} == {running_id}
+    assert {task["task_id"] for task in completed_tasks} == {completed_id}
+
+
+def test_get_execution_timeline_orders_by_indices(data_manager):
+    task_id = "task-timeline"
+    _create_task(data_manager, task_id)
+
+    op_first = data_manager.create_operation(
+        task_id, "gs_161_data_acquisition", runtime_index=0, chain_index=0, input_data={"order": 1}
+    )
+    op_second = data_manager.create_operation(
+        task_id, "gs_161_data_preparation", runtime_index=0, chain_index=1, input_data={"order": 2}
+    )
+    data_manager.update_operation_status(op_first, "done")
+    data_manager.update_operation_status(op_second, "done")
+
+    timeline = data_manager.get_execution_timeline(task_id)
+    assert [entry["input_data"]["order"] for entry in timeline] == [1, 2]

fusesell_local/tests/test_data_manager_teams.py

@@ -0,0 +1,133 @@
+def _team_payload(team_id: str = "team-001", **overrides):
+    payload = {
+        "team_id": team_id,
+        "org_id": "org-123",
+        "org_name": "FuseSell Org",
+        "plan_id": "plan-456",
+        "plan_name": "FuseSell AI",
+        "project_code": "proj-001",
+        "name": "Outbound Squad",
+        "description": "Primary outreach team",
+        "avatar": "https://fusesell.test/avatar.png",
+    }
+    payload.update(overrides)
+    return payload
+
+
+def test_save_and_get_team_roundtrip(data_manager):
+    payload = _team_payload()
+    data_manager.save_team(**payload)
+
+    stored = data_manager.get_team(payload["team_id"])
+    assert stored is not None
+    assert stored["team_id"] == payload["team_id"]
+    assert stored["name"] == payload["name"]
+    assert stored["plan_id"] == payload["plan_id"]
+
+
+def test_update_team_modifies_selected_fields(data_manager):
+    payload = _team_payload()
+    data_manager.save_team(**payload)
+
+    updated_name = "Expansion Squad"
+    updated_plan = "FuseSell AI Enterprise"
+    assert data_manager.update_team(
+        payload["team_id"], name=updated_name, plan_name=updated_plan
+    )
+
+    stored = data_manager.get_team(payload["team_id"])
+    assert stored["name"] == updated_name
+    assert stored["plan_name"] == updated_plan
+
+
+def test_list_teams_returns_all_for_org(data_manager):
+    first = _team_payload("team-001")
+    second = _team_payload("team-002", name="Inbound Squad")
+    data_manager.save_team(**first)
+    data_manager.save_team(**second)
+
+    teams = data_manager.list_teams(first["org_id"])
+    identifiers = {team["team_id"] for team in teams}
+    assert identifiers == {first["team_id"], second["team_id"]}
+
+
+def test_save_and_get_team_settings_roundtrip(data_manager):
+    payload = _team_payload()
+    data_manager.save_team(**payload)
+
+    data_manager.save_team_settings(
+        team_id=payload["team_id"],
+        org_id=payload["org_id"],
+        plan_id=payload["plan_id"],
+        team_name=payload["name"],
+        gs_team_organization={"sales_regions": ["NA", "EU"]},
+        gs_team_rep=[{"name": "Alex"}],
+        gs_team_product=[{"product_id": "prod-001"}],
+        gs_team_schedule_time={"timezone": "UTC"},
+        gs_team_initial_outreach={"enabled": True},
+        gs_team_follow_up={"sequence": 2},
+        gs_team_auto_interaction={"mode": "assist"},
+        gs_team_followup_schedule_time={"window": "business_hours"},
+        gs_team_birthday_email={"enabled": False},
+    )
+
+    settings = data_manager.get_team_settings(payload["team_id"])
+    assert settings is not None
+    assert settings["org_id"] == payload["org_id"]
+    assert settings["gs_team_organization"]["sales_regions"] == ["NA", "EU"]
+    assert settings["gs_team_rep"][0]["name"] == "Alex"
+    assert settings["gs_team_product"][0]["product_id"] == "prod-001"
+
+
+def test_save_team_settings_updates_existing_record(data_manager):
+    payload = _team_payload()
+    data_manager.save_team(**payload)
+
+    data_manager.save_team_settings(
+        team_id=payload["team_id"],
+        org_id=payload["org_id"],
+        plan_id=payload["plan_id"],
+        team_name=payload["name"],
+        gs_team_schedule_time={"timezone": "UTC"},
+    )
+
+    data_manager.save_team_settings(
+        team_id=payload["team_id"],
+        org_id=payload["org_id"],
+        plan_id=payload["plan_id"],
+        team_name=payload["name"],
+        gs_team_schedule_time={"timezone": "America/New_York"},
+    )
+
+    settings = data_manager.get_team_settings(payload["team_id"])
+    assert settings["gs_team_schedule_time"]["timezone"] == "America/New_York"
+
+
+def test_get_products_by_team_uses_team_settings(data_manager):
+    team = _team_payload()
+    data_manager.save_team(**team)
+
+    product_payload = {
+        "product_id": "prod-001",
+        "org_id": team["org_id"],
+        "org_name": team["org_name"],
+        "project_code": team["project_code"],
+        "productName": "FuseSell Starter",
+        "shortDescription": "Entry-level automation",
+        "longDescription": "Starter bundle.",
+        "category": "Software",
+        "targetUsers": ["SMB"],
+    }
+    data_manager.save_product(product_payload)
+
+    data_manager.save_team_settings(
+        team_id=team["team_id"],
+        org_id=team["org_id"],
+        plan_id=team["plan_id"],
+        team_name=team["name"],
+        gs_team_product=[{"product_id": product_payload["product_id"]}],
+    )
+
+    products = data_manager.get_products_by_team(team["team_id"])
+    assert len(products) == 1
+    assert products[0]["product_id"] == product_payload["product_id"]

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:
         """
@@ -2135,73 +2212,101 @@ class LocalDataManager:
                     "SELECT COUNT(*) FROM team_settings WHERE org_id = 'rta'")
                 team_count = cursor.fetchone()[0]
 
-                if team_count == 0:
-                    default_team_settings = {
-                        'id': 'team_rta_default_settings',
-                        'team_id': 'team_rta_default',
-                        'org_id': 'rta',
-                        'plan_id': '569cdcbd-cf6d-4e33-b0b2-d2f6f15a0832',
-                        'plan_name': 'FuseSell AI (v1.025)',
-                        'project_code': 'FUSESELL',
-                        'team_name': 'RTA Default Team',
-                        'organization_settings': json.dumps({
-                            'name': 'RTA',
-                            'industry': 'Technology',
-                            'website': 'https://rta.vn'
-                        }),
-                        'sales_rep_settings': json.dumps([{
-                            'name': 'Sales Team',
-                            'email': 'sales@rta.vn',
-                            'position': 'Sales Representative',
-                            'is_primary': True
-                        }]),
-                        'product_settings': json.dumps([
-                            {'product_id': 'prod-12345678-1234-1234-1234-123456789012',
-                                'enabled': True, 'priority': 1},
-                            {'product_id': 'prod-87654321-4321-4321-4321-210987654321',
-                                'enabled': True, 'priority': 2}
-                        ]),
-                        'schedule_time_settings': json.dumps({
-                            'business_hours_start': '08:00',
-                            'business_hours_end': '20:00',
-                            'default_delay_hours': 2,
-                            'respect_weekends': True
-                        }),
-                        'initial_outreach_settings': json.dumps({
-                            'default_tone': 'professional',
-                            'approaches': ['professional_direct', 'consultative', 'industry_expert', 'relationship_building'],
-                            'subject_line_variations': 4
-                        }),
-                        'follow_up_settings': json.dumps({
-                            'max_follow_ups': 5,
-                            'default_interval_days': 3,
-                            'strategies': ['gentle_reminder', 'value_add', 'alternative_approach', 'final_attempt', 'graceful_farewell']
-                        })
-                    }
-
-                    cursor.execute("""
-                        INSERT INTO team_settings 
-                        (id, team_id, org_id, plan_id, plan_name, project_code, team_name,
-                         organization_settings, sales_rep_settings, product_settings,
-                         schedule_time_settings, initial_outreach_settings, follow_up_settings)
-                        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                    """, (
-                        default_team_settings['id'],
-                        default_team_settings['team_id'],
-                        default_team_settings['org_id'],
-                        default_team_settings['plan_id'],
-                        default_team_settings['plan_name'],
-                        default_team_settings['project_code'],
-                        default_team_settings['team_name'],
-                        default_team_settings['organization_settings'],
-                        default_team_settings['sales_rep_settings'],
-                        default_team_settings['product_settings'],
-                        default_team_settings['schedule_time_settings'],
-                        default_team_settings['initial_outreach_settings'],
-                        default_team_settings['follow_up_settings']
-                    ))
-
-                    self.logger.debug("Initialized default team settings")
+                if team_count == 0:
+                    default_team_settings = {
+                        'id': 'team_rta_default_settings',
+                        'team_id': 'team_rta_default',
+                        'org_id': 'rta',
+                        'plan_id': '569cdcbd-cf6d-4e33-b0b2-d2f6f15a0832',
+                        'plan_name': 'FuseSell AI (v1.025)',
+                        'project_code': 'FUSESELL',
+                        'team_name': 'RTA Default Team',
+                        'gs_team_organization': json.dumps({
+                            'name': 'RTA',
+                            'industry': 'Technology',
+                            'website': 'https://rta.vn'
+                        }),
+                        'gs_team_rep': json.dumps([{
+                            'name': 'Sales Team',
+                            'email': 'sales@rta.vn',
+                            'position': 'Sales Representative',
+                            'is_primary': True
+                        }]),
+                        'gs_team_product': json.dumps([
+                            {'product_id': 'prod-12345678-1234-1234-1234-123456789012',
+                             'enabled': True, 'priority': 1},
+                            {'product_id': 'prod-87654321-4321-4321-4321-210987654321',
+                             'enabled': True, 'priority': 2}
+                        ]),
+                        'gs_team_schedule_time': json.dumps({
+                            'business_hours_start': '08:00',
+                            'business_hours_end': '20:00',
+                            'default_delay_hours': 2,
+                            'respect_weekends': True
+                        }),
+                        'gs_team_initial_outreach': json.dumps({
+                            'default_tone': 'professional',
+                            'approaches': [
+                                'professional_direct',
+                                'consultative',
+                                'industry_expert',
+                                'relationship_building'
+                            ],
+                            'subject_line_variations': 4
+                        }),
+                        'gs_team_follow_up': json.dumps({
+                            'max_follow_ups': 5,
+                            'default_interval_days': 3,
+                            'strategies': [
+                                'gentle_reminder',
+                                'value_add',
+                                'alternative_approach',
+                                'final_attempt',
+                                'graceful_farewell'
+                            ]
+                        }),
+                        'gs_team_auto_interaction': json.dumps({
+                            'enabled': True,
+                            'handoff_threshold': 0.8,
+                            'monitoring': 'standard'
+                        }),
+                        'gs_team_followup_schedule_time': json.dumps({
+                            'timezone': 'Asia/Ho_Chi_Minh',
+                            'window': 'business_hours'
+                        }),
+                        'gs_team_birthday_email': json.dumps({
+                            'enabled': True,
+                            'template': 'birthday_2025'
+                        })
+                    }
+
+                    cursor.execute("""
+                        INSERT INTO team_settings 
+                        (id, team_id, org_id, plan_id, plan_name, project_code, team_name,
+                         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)
+                        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    """, (
+                        default_team_settings['id'],
+                        default_team_settings['team_id'],
+                        default_team_settings['org_id'],
+                        default_team_settings['plan_id'],
+                        default_team_settings['plan_name'],
+                        default_team_settings['project_code'],
+                        default_team_settings['team_name'],
+                        default_team_settings['gs_team_organization'],
+                        default_team_settings['gs_team_rep'],
+                        default_team_settings['gs_team_product'],
+                        default_team_settings['gs_team_schedule_time'],
+                        default_team_settings['gs_team_initial_outreach'],
+                        default_team_settings['gs_team_follow_up'],
+                        default_team_settings['gs_team_auto_interaction'],
+                        default_team_settings['gs_team_followup_schedule_time'],
+                        default_team_settings['gs_team_birthday_email']
+                    ))
+
+                    self.logger.debug("Initialized default team settings")
 
                 conn.commit()