better-notion 2.2.0__py3-none-any.whl → 2.3.1__py3-none-any.whl

better_notion/plugins/official/agents_sdk/search.py

@@ -0,0 +1,421 @@
+"""Full-text search implementation for the agents SDK.
+
+This module provides text-based search functionality across all entity types
+with relevance scoring and filtering capabilities.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from better_notion._sdk.client import NotionClient
+
+
+class SearchResult:
+    """Represents a search result with relevance information.
+
+    Attributes:
+        entity: The entity (Task, Idea, Incident, WorkIssue, etc.)
+        relevance: Relevance level ("high", "medium", "low", "none")
+        matched_in: List of fields that matched (e.g., ["title", "description"])
+    """
+
+    def __init__(
+        self,
+        entity: Any,
+        relevance: str,
+        matched_in: list[str],
+    ) -> None:
+        """Initialize a SearchResult.
+
+        Args:
+            entity: The entity that matched
+            relevance: Relevance level
+            matched_in: Which fields matched the query
+        """
+        self.entity = entity
+        self.relevance = relevance
+        self.matched_in = matched_in
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert search result to dictionary.
+
+        Returns:
+            Dictionary with entity details and search metadata
+        """
+        result = {
+            "id": self.entity.id,
+            "title": self.entity.title,
+            "status": getattr(self.entity, "status", None),
+            "relevance": self.relevance,
+            "matched_in": self.matched_in,
+        }
+
+        # Add entity-specific fields
+        result.update(self._entity_specific_fields())
+
+        return result
+
+    def _entity_specific_fields(self) -> dict[str, Any]:
+        """Get entity-specific fields for output.
+
+        Returns:
+            Dictionary of entity-specific properties
+        """
+        result = {}
+
+        # Import entity types to check instance
+        from better_notion.plugins.official.agents_sdk.models import (
+            Idea,
+            Incident,
+            Task,
+            WorkIssue,
+        )
+
+        if isinstance(self.entity, Task):
+            result["priority"] = getattr(self.entity, "priority", None)
+            result["type"] = getattr(self.entity, "task_type", None)
+        elif isinstance(self.entity, Idea):
+            result["category"] = getattr(self.entity, "category", None)
+            result["effort"] = getattr(self.entity, "effort_estimate", None)
+        elif isinstance(self.entity, Incident):
+            result["severity"] = getattr(self.entity, "severity", None)
+            result["incident_type"] = getattr(self.entity, "incident_type", None)
+        elif isinstance(self.entity, WorkIssue):
+            result["severity"] = getattr(self.entity, "severity", None)
+            result["issue_type"] = getattr(self.entity, "issue_type", None)
+
+        return result
+
+
+class TextSearcher:
+    """Full-text search implementation for entities.
+
+    Provides client-side text search with relevance scoring across
+    Tasks, Ideas, Incidents, and WorkIssues.
+    """
+
+    def __init__(self, client: NotionClient) -> None:
+        """Initialize the TextSearcher.
+
+        Args:
+            client: Notion API client
+        """
+        self._client = client
+
+    def _calculate_relevance(
+        self,
+        query: str,
+        title: str,
+        description: str | None = None,
+    ) -> tuple[str, list[str]]:
+        """Calculate relevance score and matched fields.
+
+        Args:
+            query: Search query (lowercase)
+            title: Entity title
+            description: Entity description (optional)
+
+        Returns:
+            Tuple of (relevance_level, matched_fields)
+            - relevance_level: "high", "medium", "low", or "none"
+            - matched_fields: List of field names that matched
+        """
+        query_lower = query.lower()
+        title_lower = title.lower()
+        matched_in = []
+
+        # Check title
+        title_match = query_lower in title_lower
+        if title_match:
+            matched_in.append("title")
+
+        # Check description
+        desc_match = False
+        if description:
+            desc_lower = description.lower()
+            desc_match = query_lower in desc_lower
+            if desc_match:
+                matched_in.append("description")
+
+        # Calculate relevance
+        if not matched_in:
+            return "none", []
+
+        if title_match and desc_match:
+            return "high", matched_in
+        elif title_match:
+            # Exact phrase match or single word match in title = high relevance
+            if query_lower == title_lower or query_lower in title_lower.split():
+                return "high", matched_in
+            return "medium", matched_in
+        elif desc_match:
+            return "low", matched_in
+
+        return "none", []
+
+    async def search_tasks(
+        self,
+        query: str,
+        database_id: str,
+        filters: dict[str, Any] | None = None,
+        limit: int = 50,
+    ) -> list[SearchResult]:
+        """Search tasks by text query.
+
+        Args:
+            query: Text search query
+            database_id: Tasks database ID
+            filters: Optional Notion filters to apply
+            limit: Maximum number of results to return
+
+        Returns:
+            List of SearchResults sorted by relevance
+        """
+        from better_notion.plugins.official.agents_sdk.models import Task
+
+        # Build query object
+        query_obj: dict[str, Any] = {}
+        if filters:
+            query_obj["filter"] = filters
+
+        # Query the database
+        response = await self._client._api._request(
+            "POST",
+            f"/databases/{database_id}/query",
+            json=query_obj,
+        )
+
+        results = []
+        for page_data in response.get("results", []):
+            task = Task(self._client, page_data)
+
+            # Get description if available
+            description = None
+            if hasattr(task, "description"):
+                description = task.description
+
+            # Calculate relevance
+            relevance, matched_in = self._calculate_relevance(query, task.title, description)
+
+            if relevance != "none":
+                results.append(SearchResult(task, relevance, matched_in))
+
+        # Sort by relevance (high > medium > low) and then by title
+        results.sort(
+            key=lambda r: (
+                {"high": 0, "medium": 1, "low": 2}[r.relevance],
+                r.entity.title,
+            )
+        )
+
+        return results[:limit]
+
+    async def search_ideas(
+        self,
+        query: str,
+        database_id: str,
+        filters: dict[str, Any] | None = None,
+        limit: int = 50,
+    ) -> list[SearchResult]:
+        """Search ideas by text query.
+
+        Args:
+            query: Text search query
+            database_id: Ideas database ID
+            filters: Optional Notion filters to apply
+            limit: Maximum number of results to return
+
+        Returns:
+            List of SearchResults sorted by relevance
+        """
+        from better_notion.plugins.official.agents_sdk.models import Idea
+
+        query_obj: dict[str, Any] = {}
+        if filters:
+            query_obj["filter"] = filters
+
+        response = await self._client._api._request(
+            "POST",
+            f"/databases/{database_id}/query",
+            json=query_obj,
+        )
+
+        results = []
+        for page_data in response.get("results", []):
+            idea = Idea(self._client, page_data)
+
+            description = None
+            if hasattr(idea, "description"):
+                description = idea.description
+
+            relevance, matched_in = self._calculate_relevance(query, idea.title, description)
+
+            if relevance != "none":
+                results.append(SearchResult(idea, relevance, matched_in))
+
+        results.sort(
+            key=lambda r: (
+                {"high": 0, "medium": 1, "low": 2}[r.relevance],
+                r.entity.title,
+            )
+        )
+
+        return results[:limit]
+
+    async def search_incidents(
+        self,
+        query: str,
+        database_id: str,
+        filters: dict[str, Any] | None = None,
+        limit: int = 50,
+    ) -> list[SearchResult]:
+        """Search incidents by text query.
+
+        Args:
+            query: Text search query
+            database_id: Incidents database ID
+            filters: Optional Notion filters to apply
+            limit: Maximum number of results to return
+
+        Returns:
+            List of SearchResults sorted by relevance
+        """
+        from better_notion.plugins.official.agents_sdk.models import Incident
+
+        query_obj: dict[str, Any] = {}
+        if filters:
+            query_obj["filter"] = filters
+
+        response = await self._client._api._request(
+            "POST",
+            f"/databases/{database_id}/query",
+            json=query_obj,
+        )
+
+        results = []
+        for page_data in response.get("results", []):
+            incident = Incident(self._client, page_data)
+
+            description = None
+            if hasattr(incident, "description"):
+                description = incident.description
+
+            relevance, matched_in = self._calculate_relevance(query, incident.title, description)
+
+            if relevance != "none":
+                results.append(SearchResult(incident, relevance, matched_in))
+
+        results.sort(
+            key=lambda r: (
+                {"high": 0, "medium": 1, "low": 2}[r.relevance],
+                r.entity.title,
+            )
+        )
+
+        return results[:limit]
+
+    async def search_work_issues(
+        self,
+        query: str,
+        database_id: str,
+        filters: dict[str, Any] | None = None,
+        limit: int = 50,
+    ) -> list[SearchResult]:
+        """Search work issues by text query.
+
+        Args:
+            query: Text search query
+            database_id: Work Issues database ID
+            filters: Optional Notion filters to apply
+            limit: Maximum number of results to return
+
+        Returns:
+            List of SearchResults sorted by relevance
+        """
+        from better_notion.plugins.official.agents_sdk.models import WorkIssue
+
+        query_obj: dict[str, Any] = {}
+        if filters:
+            query_obj["filter"] = filters
+
+        response = await self._client._api._request(
+            "POST",
+            f"/databases/{database_id}/query",
+            json=query_obj,
+        )
+
+        results = []
+        for page_data in response.get("results", []):
+            issue = WorkIssue(self._client, page_data)
+
+            description = None
+            if hasattr(issue, "description"):
+                description = issue.description
+
+            relevance, matched_in = self._calculate_relevance(query, issue.title, description)
+
+            if relevance != "none":
+                results.append(SearchResult(issue, relevance, matched_in))
+
+        results.sort(
+            key=lambda r: (
+                {"high": 0, "medium": 1, "low": 2}[r.relevance],
+                r.entity.title,
+            )
+        )
+
+        return results[:limit]
+
+    async def search_all(
+        self,
+        query: str,
+        workspace_config: dict[str, Any],
+        limit_per_type: int = 10,
+    ) -> dict[str, Any]:
+        """Search across all entity types.
+
+        Args:
+            query: Text search query
+            workspace_config: Workspace configuration with database IDs
+            limit_per_type: Maximum results per entity type
+
+        Returns:
+            Dictionary with results for each entity type and total count
+        """
+        results = {
+            "tasks": [],
+            "ideas": [],
+            "incidents": [],
+            "work_issues": [],
+        }
+
+        # Search tasks
+        tasks_db = workspace_config.get("Tasks")
+        if tasks_db:
+            task_results = await self.search_tasks(query, tasks_db, limit=limit_per_type)
+            results["tasks"] = [r.to_dict() for r in task_results]
+
+        # Search ideas
+        ideas_db = workspace_config.get("Ideas")
+        if ideas_db:
+            idea_results = await self.search_ideas(query, ideas_db, limit=limit_per_type)
+            results["ideas"] = [r.to_dict() for r in idea_results]
+
+        # Search incidents
+        incidents_db = workspace_config.get("Incidents")
+        if incidents_db:
+            incident_results = await self.search_incidents(query, incidents_db, limit=limit_per_type)
+            results["incidents"] = [r.to_dict() for r in incident_results]
+
+        # Search work issues
+        issues_db = workspace_config.get("Work_issues")
+        if issues_db:
+            issue_results = await self.search_work_issues(query, issues_db, limit=limit_per_type)
+            results["work_issues"] = [r.to_dict() for r in issue_results]
+
+        total = sum(len(v) for v in results.values() if isinstance(v, list))
+        results["total"] = total
+
+        return results

{better_notion-2.2.0.dist-info → better_notion-2.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: better-notion
-Version: 2.2.0
+Version: 2.3.1
 Summary: A high-level Python SDK for the Notion API with developer experience in mind.
 Project-URL: Homepage, https://github.com/nesalia-inc/better-notion
 Project-URL: Documentation, https://github.com/nesalia-inc/better-notion#readme

{better_notion-2.2.0.dist-info → better_notion-2.3.1.dist-info}/RECORD

@@ -112,14 +112,17 @@ better_notion/plugins/base.py,sha256=3h9jOZzS--UqmVW3RREtcQ2h1GTWWPUryTencsJKhTM
 better_notion/plugins/loader.py,sha256=zCWsMdJyvZs1IHFm0zjEiqm_l_5jB1Uw4x30Kq8rLS4,9527
 better_notion/plugins/state.py,sha256=jH_tZWvC35hqLO4qwl2Kwq9ziWVavwCEUcCqy3s5wMY,3780
 better_notion/plugins/official/__init__.py,sha256=rPg5vdk1cEANVstMPzxcWmImtsOpdSR40JSml7h1uUk,426
-better_notion/plugins/official/agents.py,sha256=usvB2dH1oQ_BUePg2D1nSlHUvk58K3Eq4cdbFG5Fb7Q,54191
-better_notion/plugins/official/agents_cli.py,sha256=WFI-Sg2X4kyqyrB7SdaxwpKRGxsMxe1-aj3YU0eXb94,62644
+better_notion/plugins/official/agents.py,sha256=Obx5tkjsd79Dz9coctqJ5RgrlvKIGQLc3DjkGX7iDak,58609
+better_notion/plugins/official/agents_cli.py,sha256=IYnWUIhdUUY8IZFKJlwh9aNXOOzABLAGgeSbfElswjI,74809
 better_notion/plugins/official/agents_schema.py,sha256=NQRAJFoBAXRuxB9_9Eaf-4tVth-1OZh7GjmN56Yp9lA,39867
 better_notion/plugins/official/productivity.py,sha256=_-whP4pYA4HufE1aUFbIdhrjU-O9njI7xUO_Id2M1J8,8726
 better_notion/plugins/official/agents_sdk/__init__.py,sha256=luQBzZLsJ7fC5U0jFu8dfzMviiXj2SBZXcTohM53wkQ,725
-better_notion/plugins/official/agents_sdk/managers.py,sha256=EvEZAsH4-RzKh7o8OV_o8a0mRgMCxnqwyiwuj-Y1Cag,41235
+better_notion/plugins/official/agents_sdk/agent.py,sha256=qOX4hsH9VZ-GJH31g6huRQQzyzG7QRD0mXQaebXlf_o,17036
+better_notion/plugins/official/agents_sdk/history.py,sha256=W5xPuo8lWU5g1kDGOtqbi3h4-_G4vNZPea1ecL5bp14,21111
+better_notion/plugins/official/agents_sdk/managers.py,sha256=GICsrV2huEGmZ_kpUjpmBArzC4c-NMzPqm1AgsGg_ek,54693
 better_notion/plugins/official/agents_sdk/models.py,sha256=vBSqf-9Q-gX14Z8779Nacr8yTI3WMi5cLtkJjONiPoY,91967
 better_notion/plugins/official/agents_sdk/plugin.py,sha256=bs9O8Unv6SARGj4lBU5Gj9HGbLTUNqTacJ3RLUhdbI4,4479
+better_notion/plugins/official/agents_sdk/search.py,sha256=MCfkxm7cjYH-im__bOMq8duTNEbRqmH8PV4uCVSjElA,13401
 better_notion/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 better_notion/utils/helpers.py,sha256=HgFuUQlG_HzBOB0z2GA9RxPLoXgwRc0DIxa9Fg6C-Jk,2337
 better_notion/utils/retry.py,sha256=9WJDNitiIfVTL18hIlipvOKn41ukePrOwtAwx-LevpQ,7479
@@ -133,8 +136,8 @@ better_notion/utils/agents/rbac.py,sha256=8ZA8Y7wbOiVZDbpjpH7iC35SZrZ0jl4fcJ3xWC
 better_notion/utils/agents/schemas.py,sha256=RM6XPNA_CdtlNgKAFpN0p0Ppqqo6849RX37ODBp088o,22956
 better_notion/utils/agents/state_machine.py,sha256=xUBEeDTbU1Xq-rsRo2sbr6AUYpYrV9DTHOtZT2cWES8,6699
 better_notion/utils/agents/workspace.py,sha256=2_dK58fifMqSEifFxThI7ir_1UR9KLN-d6R4CkdNqjQ,26538
-better_notion-2.2.0.dist-info/METADATA,sha256=uj6RsRMipVhH2v4gKaSjOMKSgdd0jxT_VClz62l7NY0,11096
-better_notion-2.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-better_notion-2.2.0.dist-info/entry_points.txt,sha256=D0bUcP7Z00Zyjxw7r2p29T95UrwioDO0aGDoHe9I6fo,55
-better_notion-2.2.0.dist-info/licenses/LICENSE,sha256=BAdN3JpgMY_y_fWqZSCFSvSbC2mTHP-BKDAzF5FXQAI,1069
-better_notion-2.2.0.dist-info/RECORD,,
+better_notion-2.3.1.dist-info/METADATA,sha256=SQ75uKGrHKNO42NJYadBPTMYJVRoTgqlOpzDIkfVk0c,11096
+better_notion-2.3.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+better_notion-2.3.1.dist-info/entry_points.txt,sha256=D0bUcP7Z00Zyjxw7r2p29T95UrwioDO0aGDoHe9I6fo,55
+better_notion-2.3.1.dist-info/licenses/LICENSE,sha256=BAdN3JpgMY_y_fWqZSCFSvSbC2mTHP-BKDAzF5FXQAI,1069
+better_notion-2.3.1.dist-info/RECORD,,