better-notion 2.0.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

better_notion/plugins/official/agents.py

@@ -910,8 +910,51 @@ class AgentsPlugin(CombinedPluginInterface):
             typer.echo(agents_cli.tasks_complete(task_id, actual_hours))
 
         @tasks_app.command("can-start")
-        def tasks_can_start_cmd(task_id: str):
-            typer.echo(agents_cli.tasks_can_start(task_id))
+        def tasks_can_start_cmd(
+            task_id: str,
+            explain: bool = typer.Option(False, "--explain", help="Show detailed explanation of blocking tasks")
+        ):
+            typer.echo(agents_cli.tasks_can_start(task_id, explain))
+
+        @tasks_app.command("deps")
+        def tasks_deps_cmd(task_id: str):
+            typer.echo(agents_cli.tasks_deps(task_id))
+
+        @tasks_app.command("ready")
+        def tasks_ready_cmd(
+            version_id: str = typer.Option(None, "--version-id", "-v", help="Filter by version ID")
+        ):
+            typer.echo(agents_cli.tasks_ready(version_id))
+
+        @tasks_app.command("assign")
+        def tasks_assign_cmd(
+            task_id: str,
+            to: str = typer.Option(..., "--to", help="Person to assign to")
+        ):
+            typer.echo(agents_cli.tasks_assign(task_id, to))
+
+        @tasks_app.command("unassign")
+        def tasks_unassign_cmd(task_id: str):
+            typer.echo(agents_cli.tasks_unassign(task_id))
+
+        @tasks_app.command("reassign")
+        def tasks_reassign_cmd(
+            task_id: str,
+            from_: str = typer.Option(..., "--from", help="Current assignee (for validation)"),
+            to: str = typer.Option(..., "--to", help="New assignee")
+        ):
+            typer.echo(agents_cli.tasks_reassign(task_id, from_, to))
+
+        @tasks_app.command("list-by-assignee")
+        def tasks_list_by_assignee_cmd(
+            assignee: str,
+            status: str = typer.Option(None, "--status", "-s", help="Filter by status")
+        ):
+            typer.echo(agents_cli.tasks_list_by_assignee(assignee, status))
+
+        @tasks_app.command("list-unassigned")
+        def tasks_list_unassigned_cmd():
+            typer.echo(agents_cli.tasks_list_unassigned())
 
         agents_app.add_typer(tasks_app)
 
@@ -997,6 +1040,10 @@ class AgentsPlugin(CombinedPluginInterface):
         def work_issues_blockers_cmd(project_id: str):
             typer.echo(agents_cli.work_issues_blockers(project_id))
 
+        @work_issues_app.command("list-blocked-by")
+        def work_issues_list_blocked_by_cmd(work_issue_id: str):
+            typer.echo(agents_cli.work_issues_list_blocked_by(work_issue_id))
+
         agents_app.add_typer(work_issues_app)
 
         # Incidents commands (under agents)
@@ -1041,6 +1088,21 @@ class AgentsPlugin(CombinedPluginInterface):
         def incidents_sla_violations_cmd():
             typer.echo(agents_cli.incidents_sla_violations())
 
+        @incidents_app.command("link-to-work-issue")
+        def incidents_link_to_work_issue_cmd(
+            incident_id: str,
+            work_issue_id: str
+        ):
+            typer.echo(agents_cli.incidents_link_to_work_issue(incident_id, work_issue_id))
+
+        @incidents_app.command("unlink-work-issue")
+        def incidents_unlink_work_issue_cmd(incident_id: str):
+            typer.echo(agents_cli.incidents_unlink_work_issue(incident_id))
+
+        @incidents_app.command("list-caused-by")
+        def incidents_list_caused_by_cmd(work_issue_id: str):
+            typer.echo(agents_cli.incidents_list_caused_by(work_issue_id))
+
         agents_app.add_typer(incidents_app)
 
     def register_sdk_models(self) -> dict[str, type]:

better_notion/plugins/official/agents_cli.py

@@ -820,15 +820,17 @@ def tasks_complete(
     return asyncio.run(_complete())
 
 
-def tasks_can_start(task_id: str) -> str:
+def tasks_can_start(task_id: str, explain: bool = False) -> str:
     """
     Check if a task can start (all dependencies completed).
 
     Args:
         task_id: Task page ID
+        explain: Show detailed explanation of blocking tasks
 
     Example:
         $ notion tasks can-start task_123
+        $ notion tasks can-start task_123 --explain
     """
     async def _can_start() -> str:
         try:
@@ -837,33 +839,17 @@ def tasks_can_start(task_id: str) -> str:
             # Register SDK plugin
             register_agents_sdk_plugin(client)
 
-            # Get task and check
+            # Use manager method for detailed info
             manager = client.plugin_manager("tasks")
-            task = await manager.get(task_id)
-            can_start = await task.can_start()
-
-            if not can_start:
-                # Get incomplete dependencies
-                incomplete = []
-                for dep in await task.dependencies():
-                    if dep.status != "Completed":
-                        incomplete.append({
-                            "id": dep.id,
-                            "title": dep.title,
-                            "status": dep.status,
-                        })
+            result = await manager.can_start(task_id)
 
-                return format_success({
-                    "task_id": task.id,
-                    "can_start": False,
-                    "incomplete_dependencies": incomplete,
-                })
+            if explain and not result["can_start"]:
+                result["explanation"] = {
+                    "blocking_tasks": result["incomplete_dependencies"],
+                    "suggestion": "Wait for dependencies to complete before starting"
+                }
 
-            return format_success({
-                "task_id": task.id,
-                "can_start": True,
-                "message": "All dependencies are completed",
-            })
+            return format_success(result)
 
         except Exception as e:
             return format_error("CAN_START_ERROR", str(e), retry=False)
@@ -871,6 +857,248 @@ def tasks_can_start(task_id: str) -> str:
     return asyncio.run(_can_start())
 
 
+def tasks_deps(task_id: str) -> str:
+    """
+    List all dependencies of a task.
+
+    Args:
+        task_id: Task page ID
+
+    Example:
+        $ notion tasks deps task_123
+    """
+    async def _deps() -> str:
+        try:
+            client = get_client()
+
+            # Register SDK plugin
+            register_agents_sdk_plugin(client)
+
+            # Use manager method
+            manager = client.plugin_manager("tasks")
+            result = await manager.deps(task_id)
+
+            return format_success(result)
+
+        except Exception as e:
+            return format_error("DEPS_ERROR", str(e), retry=False)
+
+    return asyncio.run(_deps())
+
+
+def tasks_ready(version_id: Optional[str] = None) -> str:
+    """
+    List all tasks ready to start (dependencies completed).
+
+    Args:
+        version_id: Filter by version ID
+
+    Example:
+        $ notion tasks ready
+        $ notion tasks ready --version-id ver_123
+    """
+    async def _ready() -> str:
+        try:
+            client = get_client()
+
+            # Register SDK plugin
+            register_agents_sdk_plugin(client)
+
+            # Use manager method
+            manager = client.plugin_manager("tasks")
+            tasks = await manager.ready(version_id)
+
+            return format_success({
+                "ready_tasks": [
+                    {
+                        "id": task.id,
+                        "title": task.title,
+                        "status": task.status,
+                        "priority": task.priority,
+                    }
+                    for task in tasks
+                ],
+                "total": len(tasks)
+            })
+
+        except Exception as e:
+            return format_error("READY_ERROR", str(e), retry=False)
+
+    return asyncio.run(_ready())
+
+
+def tasks_assign(task_id: str, to: str) -> str:
+    """
+    Assign a task to a person.
+
+    Args:
+        task_id: Task page ID
+        to: Name of the person to assign to
+
+    Example:
+        $ notion tasks assign task_123 --to "Alice Chen"
+    """
+    async def _assign() -> str:
+        try:
+            client = get_client()
+
+            # Register SDK plugin
+            register_agents_sdk_plugin(client)
+
+            # Use manager method
+            manager = client.plugin_manager("tasks")
+            result = await manager.assign(task_id, to)
+
+            return format_success(result)
+
+        except Exception as e:
+            return format_error("ASSIGN_ERROR", str(e), retry=False)
+
+    return asyncio.run(_assign())
+
+
+def tasks_unassign(task_id: str) -> str:
+    """
+    Unassign a task.
+
+    Args:
+        task_id: Task page ID
+
+    Example:
+        $ notion tasks unassign task_123
+    """
+    async def _unassign() -> str:
+        try:
+            client = get_client()
+
+            # Register SDK plugin
+            register_agents_sdk_plugin(client)
+
+            # Use manager method
+            manager = client.plugin_manager("tasks")
+            result = await manager.unassign(task_id)
+
+            return format_success(result)
+
+        except Exception as e:
+            return format_error("UNASSIGN_ERROR", str(e), retry=False)
+
+    return asyncio.run(_unassign())
+
+
+def tasks_reassign(task_id: str, from_: str, to: str) -> str:
+    """
+    Reassign a task from one person to another.
+
+    Args:
+        task_id: Task page ID
+        from_: Current assignee (for validation)
+        to: New assignee
+
+    Example:
+        $ notion tasks reassign task_123 --from "Alice" --to "Bob"
+    """
+    async def _reassign() -> str:
+        try:
+            client = get_client()
+
+            # Register SDK plugin
+            register_agents_sdk_plugin(client)
+
+            # Use manager method
+            manager = client.plugin_manager("tasks")
+            result = await manager.reassign(task_id, from_, to)
+
+            return format_success(result)
+
+        except Exception as e:
+            return format_error("REASSIGN_ERROR", str(e), retry=False)
+
+    return asyncio.run(_reassign())
+
+
+def tasks_list_by_assignee(
+    assignee: str,
+    status: Optional[str] = None
+) -> str:
+    """
+    List tasks assigned to a person.
+
+    Args:
+        assignee: Name of the assignee
+        status: Optional status filter
+
+    Example:
+        $ notion tasks list-by-assignee "Alice Chen"
+        $ notion tasks list-by-assignee "Alice" --status "In Progress"
+    """
+    async def _list_by_assignee() -> str:
+        try:
+            client = get_client()
+
+            # Register SDK plugin
+            register_agents_sdk_plugin(client)
+
+            # Use manager method
+            manager = client.plugin_manager("tasks")
+            tasks = await manager.list_by_assignee(assignee, status)
+
+            return format_success({
+                "tasks": [
+                    {
+                        "id": task.id,
+                        "title": task.title,
+                        "status": task.status,
+                        "priority": task.priority,
+                    }
+                    for task in tasks
+                ],
+                "total": len(tasks)
+            })
+
+        except Exception as e:
+            return format_error("LIST_BY_ASSIGNEE_ERROR", str(e), retry=False)
+
+    return asyncio.run(_list_by_assignee())
+
+
+def tasks_list_unassigned() -> str:
+    """
+    List unassigned tasks.
+
+    Example:
+        $ notion tasks list-unassigned
+    """
+    async def _list_unassigned() -> str:
+        try:
+            client = get_client()
+
+            # Register SDK plugin
+            register_agents_sdk_plugin(client)
+
+            # Use manager method
+            manager = client.plugin_manager("tasks")
+            tasks = await manager.list_unassigned()
+
+            return format_success({
+                "unassigned_tasks": [
+                    {
+                        "id": task.id,
+                        "title": task.title,
+                        "status": task.status,
+                        "priority": task.priority,
+                    }
+                    for task in tasks
+                ],
+                "total": len(tasks)
+            })
+
+        except Exception as e:
+            return format_error("LIST_UNASSIGNED_ERROR", str(e), retry=False)
+
+    return asyncio.run(_list_unassigned())
+
+
 # ===== IDEAS =====
 
 def ideas_list(
@@ -1432,6 +1660,46 @@ def work_issues_blockers(project_id: str) -> str:
     return asyncio.run(_blockers())
 
 
+def work_issues_list_blocked_by(work_issue_id: str) -> str:
+    """
+    List tasks blocked by a work issue.
+
+    Args:
+        work_issue_id: Work issue page ID
+
+    Example:
+        $ notion work-issues list-blocked-by issue_456
+    """
+    async def _list_blocked_by() -> str:
+        try:
+            client = get_client()
+
+            # Register SDK plugin
+            register_agents_sdk_plugin(client)
+
+            # Use manager method
+            manager = client.plugin_manager("work_issues")
+            tasks = await manager.list_blocked_by(work_issue_id)
+
+            return format_success({
+                "blocked_tasks": [
+                    {
+                        "id": task.id,
+                        "title": task.title,
+                        "status": task.status,
+                        "priority": task.priority,
+                    }
+                    for task in tasks
+                ],
+                "total": len(tasks)
+            })
+
+        except Exception as e:
+            return format_error("LIST_BLOCKED_BY_ERROR", str(e), retry=False)
+
+    return asyncio.run(_list_blocked_by())
+
+
 # ===== INCIDENTS =====
 
 def incidents_list(
@@ -1572,8 +1840,8 @@ def incidents_create(
                 "Project": {"relation": [{"id": project_id}]},
                 "Severity": {"select": {"name": severity}},
                 "Type": {"select": {"name": type}},
-                "Status": {"select": {"name": "Active"}},
-                "Discovery Date": {
+                "Status": {"select": {"name": "Open"}},
+                "Detected Date": {
                     "date": {"start": datetime.now(timezone.utc).isoformat()}
                 },
             }
@@ -1726,3 +1994,102 @@ def incidents_sla_violations() -> str:
             return format_error("SLA_VIOLATIONS_ERROR", str(e), retry=False)
 
     return asyncio.run(_sla_violations())
+
+
+def incidents_link_to_work_issue(incident_id: str, work_issue_id: str) -> str:
+    """
+    Link an incident to a work issue (root cause).
+
+    Args:
+        incident_id: Incident page ID
+        work_issue_id: Work issue page ID
+
+    Example:
+        $ notion incidents link-to-work-issue inc_123 issue_456
+    """
+    async def _link_to_work_issue() -> str:
+        try:
+            client = get_client()
+
+            # Register SDK plugin
+            register_agents_sdk_plugin(client)
+
+            # Use manager method
+            manager = client.plugin_manager("incidents")
+            result = await manager.link_to_work_issue(incident_id, work_issue_id)
+
+            return format_success(result)
+
+        except Exception as e:
+            return format_error("LINK_TO_WORK_ISSUE_ERROR", str(e), retry=False)
+
+    return asyncio.run(_link_to_work_issue())
+
+
+def incidents_unlink_work_issue(incident_id: str) -> str:
+    """
+    Unlink an incident from its work issue.
+
+    Args:
+        incident_id: Incident page ID
+
+    Example:
+        $ notion incidents unlink-work-issue inc_123
+    """
+    async def _unlink_work_issue() -> str:
+        try:
+            client = get_client()
+
+            # Register SDK plugin
+            register_agents_sdk_plugin(client)
+
+            # Use manager method
+            manager = client.plugin_manager("incidents")
+            result = await manager.unlink_work_issue(incident_id)
+
+            return format_success(result)
+
+        except Exception as e:
+            return format_error("UNLINK_WORK_ISSUE_ERROR", str(e), retry=False)
+
+    return asyncio.run(_unlink_work_issue())
+
+
+def incidents_list_caused_by(work_issue_id: str) -> str:
+    """
+    List all incidents caused by a work issue.
+
+    Args:
+        work_issue_id: Work issue page ID
+
+    Example:
+        $ notion incidents list-caused-by issue_456
+    """
+    async def _list_caused_by() -> str:
+        try:
+            client = get_client()
+
+            # Register SDK plugin
+            register_agents_sdk_plugin(client)
+
+            # Use manager method
+            manager = client.plugin_manager("incidents")
+            incidents = await manager.list_caused_by(work_issue_id)
+
+            return format_success({
+                "incidents": [
+                    {
+                        "id": incident.id,
+                        "title": incident.title,
+                        "severity": incident.severity,
+                        "status": incident.status,
+                    }
+                    for incident in incidents
+                ],
+                "total": len(incidents)
+            })
+
+        except Exception as e:
+            return format_error("LIST_CAUSED_BY_ERROR", str(e), retry=False)
+
+    return asyncio.run(_list_caused_by())

better_notion/plugins/official/agents_sdk/managers.py

@@ -525,6 +525,241 @@ class TaskManager:
 
         return blocked_tasks
 
+    async def assign(self, task_id: str, assignee: str) -> dict:
+        """
+        Assign a task to a person.
+
+        Args:
+            task_id: Task ID to assign
+            assignee: Name of the person to assign to
+
+        Returns:
+            Dict with task_id, assigned_to, and previous assignee
+
+        Example:
+            >>> result = await manager.assign("task_123", "Alice Chen")
+        """
+        from better_notion.plugins.official.agents_sdk.models import Task
+
+        task = await Task.get(task_id, client=self._client)
+        previous = task.assignee
+
+        await task.assign_to(assignee)
+
+        return {
+            "task_id": task_id,
+            "assigned_to": assignee,
+            "previous": previous
+        }
+
+    async def unassign(self, task_id: str) -> dict:
+        """
+        Unassign a task.
+
+        Args:
+            task_id: Task ID to unassign
+
+        Returns:
+            Dict with task_id, assigned_to (None), and previous assignee
+
+        Example:
+            >>> result = await manager.unassign("task_123")
+        """
+        from better_notion.plugins.official.agents_sdk.models import Task
+
+        task = await Task.get(task_id, client=self._client)
+        previous = task.assignee
+
+        await task.unassign()
+
+        return {
+            "task_id": task_id,
+            "assigned_to": None,
+            "previous": previous
+        }
+
+    async def reassign(self, task_id: str, from_assignee: str, to_assignee: str) -> dict:
+        """
+        Reassign a task from one person to another.
+
+        Args:
+            task_id: Task ID to reassign
+            from_assignee: Current assignee (for validation)
+            to_assignee: New assignee
+
+        Returns:
+            Dict with task_id, from, and to
+
+        Raises:
+            ValueError: If task is not assigned to from_assignee
+
+        Example:
+            >>> result = await manager.reassign("task_123", "Alice", "Bob")
+        """
+        from better_notion.plugins.official.agents_sdk.models import Task
+
+        task = await Task.get(task_id, client=self._client)
+
+        if task.assignee != from_assignee:
+            raise ValueError(f"Task is not assigned to {from_assignee}")
+
+        await task.assign_to(to_assignee)
+
+        return {
+            "task_id": task_id,
+            "from": from_assignee,
+            "to": to_assignee
+        }
+
+    async def list_by_assignee(
+        self,
+        assignee: str,
+        status: str | None = None
+    ) -> list:
+        """
+        List tasks assigned to a person.
+
+        Args:
+            assignee: Name of the assignee
+            status: Optional status filter
+
+        Returns:
+            List of Task instances
+
+        Example:
+            >>> tasks = await manager.list_by_assignee("Alice Chen", status="In Progress")
+        """
+        from better_notion.plugins.official.agents_sdk.models import Task
+
+        database_id = self._get_database_id("Tasks")
+        if not database_id:
+            return []
+
+        filters: list[dict[str, Any]] = [
+            {
+                "property": "Assignee",
+                "select": {"equals": assignee}
+            }
+        ]
+
+        if status:
+            filters.append({
+                "property": "Status",
+                "select": {"equals": status}
+            })
+
+        response = await self._client._api.databases.query(
+            database_id=database_id,
+            filter={"and": filters} if len(filters) > 1 else filters[0]
+        )
+
+        return [
+            Task(self._client, page_data)
+            for page_data in response.get("results", [])
+        ]
+
+    async def list_unassigned(self) -> list:
+        """
+        List unassigned tasks.
+
+        Returns:
+            List of Task instances with no assignee
+
+        Example:
+            >>> tasks = await manager.list_unassigned()
+        """
+        from better_notion.plugins.official.agents_sdk.models import Task
+
+        database_id = self._get_database_id("Tasks")
+        if not database_id:
+            return []
+
+        response = await self._client._api.databases.query(
+            database_id=database_id,
+            filter={
+                "property": "Assignee",
+                "select": {"is_empty": True}
+            }
+        )
+
+        return [
+            Task(self._client, page_data)
+            for page_data in response.get("results", [])
+        ]
+
+    async def can_start(self, task_id: str) -> dict:
+        """
+        Check if a task can start (all dependencies completed).
+
+        Args:
+            task_id: Task ID to check
+
+        Returns:
+            Dict with can_start (bool), task_id, and incomplete_dependencies
+
+        Example:
+            >>> result = await manager.can_start("task_123")
+        """
+        from better_notion.plugins.official.agents_sdk.models import Task
+
+        task = await Task.get(task_id, client=self._client)
+        deps = await task.dependencies()
+        incomplete = [d for d in deps if d.status != "Completed"]
+
+        return {
+            "can_start": len(incomplete) == 0,
+            "task_id": task_id,
+            "incomplete_dependencies": [
+                {"id": d.id, "title": d.title, "status": d.status}
+                for d in incomplete
+            ]
+        }
+
+    async def deps(self, task_id: str) -> dict:
+        """
+        List all dependencies of a task.
+
+        Args:
+            task_id: Task ID
+
+        Returns:
+            Dict with task_id and dependencies list
+
+        Example:
+            >>> result = await manager.deps("task_123")
+        """
+        from better_notion.plugins.official.agents_sdk.models import Task
+
+        task = await Task.get(task_id, client=self._client)
+        deps = await task.dependencies()
+
+        return {
+            "task_id": task_id,
+            "dependencies": [
+                {
+                    "id": d.id,
+                    "title": d.title,
+                    "status": d.status
+                }
+                for d in deps
+            ]
+        }
+
+    async def ready(self, version_id: str | None = None) -> list:
+        """
+        List all tasks ready to start (dependencies completed).
+
+        Args:
+            version_id: Optional version filter
+
+        Returns:
+            List of Task instances ready to start
+
+        Example:
+            >>> tasks = await manager.ready(version_id="ver_123")
+        """
+        return await self.find_ready(version_id)
+
     def _get_database_id(self, name: str) -> str | None:
         """Get database ID from workspace config."""
         return getattr(self._client, "_workspace_config", {}).get(name)
@@ -826,6 +1061,41 @@ class WorkIssueManager:
 
         return issue
 
+    async def list_blocked_by(self, work_issue_id: str) -> list:
+        """
+        List tasks blocked by a work issue.
+
+        Args:
+            work_issue_id: Work issue ID
+
+        Returns:
+            List of Task instances
+
+        Example:
+            >>> tasks = await manager.list_blocked_by("issue_456")
+        """
+        from better_notion.plugins.official.agents_sdk.models import Task
+
+        database_id = self._get_database_id("Tasks")
+        if not database_id:
+            return []
+
+        response = await self._client._api._request(
+            "POST",
+            f"/databases/{database_id}/query",
+            json={
+                "filter": {
+                    "property": "Related Work Issue",
+                    "relation": {"contains": work_issue_id}
+                }
+            }
+        )
+
+        return [
+            Task(self._client, page_data)
+            for page_data in response.get("results", [])
+        ]
+
     def _get_database_id(self, name: str) -> str | None:
         """Get database ID from workspace config."""
         return getattr(self._client, "_workspace_config", {}).get(name)
@@ -992,6 +1262,89 @@ class IncidentManager:
 
         return mttr
 
+    async def link_to_work_issue(self, incident_id: str, work_issue_id: str) -> dict:
+        """
+        Link an incident to a work issue (root cause).
+
+        Args:
+            incident_id: Incident ID
+            work_issue_id: Work issue ID to link to
+
+        Returns:
+            Dict with incident_id and work_issue_id
+
+        Example:
+            >>> result = await manager.link_to_work_issue("inc_123", "issue_456")
+        """
+        from better_notion.plugins.official.agents_sdk.models import Incident
+
+        incident = await Incident.get(incident_id, client=self._client)
+        await incident.link_to_work_issue(work_issue_id)
+
+        return {
+            "incident_id": incident_id,
+            "work_issue_id": work_issue_id,
+            "linked": True
+        }
+
+    async def unlink_work_issue(self, incident_id: str) -> dict:
+        """
+        Unlink an incident from its work issue.
+
+        Args:
+            incident_id: Incident ID
+
+        Returns:
+            Dict with incident_id and unlinked status
+
+        Example:
+            >>> result = await manager.unlink_work_issue("inc_123")
+        """
+        from better_notion.plugins.official.agents_sdk.models import Incident
+
+        incident = await Incident.get(incident_id, client=self._client)
+        await incident.unlink_work_issue()
+
+        return {
+            "incident_id": incident_id,
+            "unlinked": True
+        }
+
+    async def list_caused_by(self, work_issue_id: str) -> list:
+        """
+        List all incidents caused by a work issue.
+
+        Args:
+            work_issue_id: Work issue ID
+
+        Returns:
+            List of Incident instances
+
+        Example:
+            >>> incidents = await manager.list_caused_by("issue_456")
+        """
+        from better_notion.plugins.official.agents_sdk.models import Incident
+
+        database_id = self._get_database_id("Incidents")
+        if not database_id:
+            return []
+
+        response = await self._client._api._request(
+            "POST",
+            f"/databases/{database_id}/query",
+            json={
+                "filter": {
+                    "property": "Root Cause Work Issue",
+                    "relation": {"contains": work_issue_id}
+                }
+            }
+        )
+
+        return [
+            Incident(self._client, page_data)
+            for page_data in response.get("results", [])
+        ]
+
     def _get_database_id(self, name: str) -> str | None:
         """Get database ID from workspace config."""
         return getattr(self._client, "_workspace_config", {}).get(name)

better_notion/plugins/official/agents_sdk/models.py

@@ -1053,6 +1053,26 @@ class Task(DatabasePageEntityMixin, BaseEntity):
             return hours_prop.get("number")
         return None
 
+    @property
+    def assignee(self) -> str | None:
+        """Get the assignee of this task."""
+        assignee_prop = self._data["properties"].get("Assignee") or self._data["properties"].get("assignee")
+        if assignee_prop and assignee_prop.get("type") == "select":
+            select_data = assignee_prop.get("select")
+            if select_data:
+                return select_data.get("name")
+        return None
+
+    @property
+    def related_work_issue_id(self) -> str | None:
+        """Get related work issue ID (blocking this task or caused by this task)."""
+        issue_prop = self._data["properties"].get("Related Work Issue") or self._data["properties"].get("related_work_issue")
+        if issue_prop and issue_prop.get("type") == "relation":
+            relations = issue_prop.get("relation", [])
+            if relations:
+                return relations[0].get("id")
+        return None
+
     # ===== AUTONOMOUS METHODS =====
 
     @classmethod
@@ -1262,6 +1282,121 @@ class Task(DatabasePageEntityMixin, BaseEntity):
                 return False
         return True
 
+    async def related_work_issue(self) -> "WorkIssue | None":
+        """
+        Get the related work issue (blocking this task or caused by this task).
+
+        Returns:
+            WorkIssue instance or None
+
+        Example:
+            >>> issue = await task.related_work_issue()
+        """
+        from better_notion.plugins.official.agents_sdk.models import WorkIssue
+
+        issue_id = self.related_work_issue_id
+        if not issue_id:
+            return None
+
+        try:
+            return await WorkIssue.get(issue_id, client=self._client)
+        except Exception:
+            return None
+
+    async def link_to_work_issue(self, work_issue_id: str) -> None:
+        """
+        Link this task to a work issue.
+
+        Args:
+            work_issue_id: Work issue ID to link to
+
+        Example:
+            >>> await task.link_to_work_issue(issue_id)
+        """
+        from better_notion._api.properties import Relation
+
+        await self._client._api.pages.update(
+            page_id=self.id,
+            properties={
+                "Related Work Issue": Relation([work_issue_id]).to_dict(),
+            },
+        )
+
+        # Update local data
+        self._data["properties"]["Related Work Issue"] = {
+            "type": "relation",
+            "relation": [{"id": work_issue_id}]
+        }
+
+    async def unlink_work_issue(self) -> None:
+        """
+        Unlink this task from its work issue.
+
+        Example:
+            >>> await task.unlink_work_issue()
+        """
+        from better_notion._api.properties import Relation
+
+        await self._client._api.pages.update(
+            page_id=self.id,
+            properties={
+                "Related Work Issue": Relation([]).to_dict(),
+            },
+        )
+
+        # Update local data
+        self._data["properties"]["Related Work Issue"] = {
+            "type": "relation",
+            "relation": []
+        }
+
+    async def assign_to(self, assignee: str) -> None:
+        """
+        Assign this task to a person.
+
+        Args:
+            assignee: Name of the person to assign to
+
+        Example:
+            >>> await task.assign_to("Alice Chen")
+        """
+        from better_notion._api.properties import Select
+
+        await self._client._api.pages.update(
+            page_id=self.id,
+            properties={
+                "Assignee": Select(name="Assignee", value=assignee).to_dict(),
+            },
+        )
+
+        # Update local data
+        self._data["properties"]["Assignee"] = {
+            "type": "select",
+            "select": {"name": assignee}
+        }
+
+    async def unassign(self) -> None:
+        """
+        Unassign this task.
+
+        Example:
+            >>> await task.unassign()
+        """
+        from better_notion._api.properties import Select
+
+        await self._client._api.pages.update(
+            page_id=self.id,
+            properties={
+                "Assignee": None,
+            },
+        )
+
+        # Update local data
+        self._data["properties"]["Assignee"] = {
+            "type": "select",
+            "select": None
+        }
+
 
 class Idea(DatabasePageEntityMixin, BaseEntity):
     """
@@ -1790,6 +1925,24 @@ class WorkIssue(DatabasePageEntityMixin, BaseEntity):
                 return relations[0].get("id")
         return None
 
+    @property
+    def caused_incident_ids(self) -> list[str]:
+        """Get incident IDs caused by this work issue."""
+        incidents_prop = self._data["properties"].get("Caused Incidents") or self._data["properties"].get("caused_incidents")
+        if incidents_prop and incidents_prop.get("type") == "relation":
+            relations = incidents_prop.get("relation", [])
+            return [r.get("id", "") for r in relations if r.get("id")]
+        return []
+
+    @property
+    def blocking_task_ids(self) -> list[str]:
+        """Get task IDs blocked by this work issue."""
+        tasks_prop = self._data["properties"].get("Blocking Tasks") or self._data["properties"].get("blocking_tasks")
+        if tasks_prop and tasks_prop.get("type") == "relation":
+            relations = tasks_prop.get("relation", [])
+            return [r.get("id", "") for r in relations if r.get("id")]
+        return []
+
     # ===== AUTONOMOUS METHODS =====
 
     @classmethod
@@ -2010,6 +2163,48 @@ class WorkIssue(DatabasePageEntityMixin, BaseEntity):
 
         return idea
 
+    async def caused_incidents(self) -> list["Incident"]:
+        """
+        Get incidents caused by this work issue.
+
+        Returns:
+            List of Incident instances
+
+        Example:
+            >>> incidents = await issue.caused_incidents()
+        """
+        from better_notion.plugins.official.agents_sdk.models import Incident
+
+        incidents = []
+        for incident_id in self.caused_incident_ids:
+            try:
+                incident = await Incident.get(incident_id, client=self._client)
+                incidents.append(incident)
+            except Exception:
+                pass
+        return incidents
+
+    async def blocking_tasks(self) -> list["Task"]:
+        """
+        Get tasks blocked by this work issue.
+
+        Returns:
+            List of Task instances
+
+        Example:
+            >>> tasks = await issue.blocking_tasks()
+        """
+        from better_notion.plugins.official.agents_sdk.models import Task
+
+        tasks = []
+        for task_id in self.blocking_task_ids:
+            try:
+                task = await Task.get(task_id, client=self._client)
+                tasks.append(task)
+            except Exception:
+                pass
+        return tasks
+
 
 class Incident(DatabasePageEntityMixin, BaseEntity):
     """
@@ -2153,6 +2348,16 @@ class Incident(DatabasePageEntityMixin, BaseEntity):
                 return date_data["start"]
         return None
 
+    @property
+    def root_cause_work_issue_id(self) -> str | None:
+        """Get the work issue ID that caused this incident."""
+        issue_prop = self._data["properties"].get("Root Cause Work Issue") or self._data["properties"].get("root_cause_work_issue")
+        if issue_prop and issue_prop.get("type") == "relation":
+            relations = issue_prop.get("relation", [])
+            if relations:
+                return relations[0].get("id")
+        return None
+
     # ===== AUTONOMOUS METHODS =====
 
     @classmethod
@@ -2405,3 +2610,71 @@ class Incident(DatabasePageEntityMixin, BaseEntity):
         await self.assign(task.id)
 
         return task
+
+    async def root_cause_work_issue(self) -> "WorkIssue | None":
+        """
+        Get the work issue that caused this incident.
+
+        Returns:
+            WorkIssue instance or None
+
+        Example:
+            >>> issue = await incident.root_cause_work_issue()
+        """
+        from better_notion.plugins.official.agents_sdk.models import WorkIssue
+
+        issue_id = self.root_cause_work_issue_id
+        if not issue_id:
+            return None
+
+        try:
+            return await WorkIssue.get(issue_id, client=self._client)
+        except Exception:
+            return None
+
+    async def link_to_work_issue(self, work_issue_id: str) -> None:
+        """
+        Link this incident to a work issue (root cause).
+
+        Args:
+            work_issue_id: Work issue ID to link to
+
+        Example:
+            >>> await incident.link_to_work_issue(issue_id)
+        """
+        from better_notion._api.properties import Relation
+
+        await self._client._api.pages.update(
+            page_id=self.id,
+            properties={
+                "Root Cause Work Issue": Relation([work_issue_id]).to_dict(),
+            },
+        )
+
+        # Update local data
+        self._data["properties"]["Root Cause Work Issue"] = {
+            "type": "relation",
+            "relation": [{"id": work_issue_id}]
+        }
+
+    async def unlink_work_issue(self) -> None:
+        """
+        Unlink this incident from its work issue.
+
+        Example:
+            >>> await incident.unlink_work_issue()
+        """
+        from better_notion._api.properties import Relation
+
+        await self._client._api.pages.update(
+            page_id=self.id,
+            properties={
+                "Root Cause Work Issue": Relation([]).to_dict(),
+            },
+        )
+
+        # Update local data
+        self._data["properties"]["Root Cause Work Issue"] = {
+            "type": "relation",
+            "relation": []
+        }

{better_notion-2.0.0.dist-info → better_notion-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: better-notion
-Version: 2.0.0
+Version: 2.1.0
 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.0.0.dist-info → better_notion-2.1.0.dist-info}/RECORD

@@ -112,13 +112,13 @@ 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=NZ50Fiw-x7JIgrF56QHjVPzGLDBpnpJHc834vFYH8Fo,51608
-better_notion/plugins/official/agents_cli.py,sha256=ybP13cfgnujPixiqiuKx8ejrzZWoWkHx8LW5dBQmXoM,52404
+better_notion/plugins/official/agents.py,sha256=usvB2dH1oQ_BUePg2D1nSlHUvk58K3Eq4cdbFG5Fb7Q,54191
+better_notion/plugins/official/agents_cli.py,sha256=M7bdEPzxpv1_EuC5rX_tlz9MZ3XYmnecp5EzLOBktrg,62551
 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=I1SuF-iEQPcRbivVtGcLfowFlGdwsAdoFKgfM7f-yc4,30824
-better_notion/plugins/official/agents_sdk/models.py,sha256=Di3K1o5HeaEj8vGd--7mPb53bgOXf9_g3QAZ5I7QYF0,83156
+better_notion/plugins/official/agents_sdk/managers.py,sha256=A1SQlozecnYrX1HLXxNWZwN0aJXoyrHIr9D1R-Jf3ZQ,40999
+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/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 better_notion/utils/helpers.py,sha256=HgFuUQlG_HzBOB0z2GA9RxPLoXgwRc0DIxa9Fg6C-Jk,2337
@@ -133,8 +133,8 @@ better_notion/utils/agents/rbac.py,sha256=8ZA8Y7wbOiVZDbpjpH7iC35SZrZ0jl4fcJ3xWC
 better_notion/utils/agents/schemas.py,sha256=eHfGhY90FAPXA3E8qE6gP75dgNzn-9z5Ju1FMwBKnQQ,22120
 better_notion/utils/agents/state_machine.py,sha256=xUBEeDTbU1Xq-rsRo2sbr6AUYpYrV9DTHOtZT2cWES8,6699
 better_notion/utils/agents/workspace.py,sha256=Uy8bqLsT_VFGYAPoiQJNuCvGdjMceaSiVGbR9saMpoU,16558
-better_notion-2.0.0.dist-info/METADATA,sha256=TmBNSZyQKCNMhe2OZ07huw3UTg66yp8cXGOzMExSN1I,11096
-better_notion-2.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-better_notion-2.0.0.dist-info/entry_points.txt,sha256=D0bUcP7Z00Zyjxw7r2p29T95UrwioDO0aGDoHe9I6fo,55
-better_notion-2.0.0.dist-info/licenses/LICENSE,sha256=BAdN3JpgMY_y_fWqZSCFSvSbC2mTHP-BKDAzF5FXQAI,1069
-better_notion-2.0.0.dist-info/RECORD,,
+better_notion-2.1.0.dist-info/METADATA,sha256=CGwOskvV6KSl4YON4CUNgzo3W0TWLWfJ83Vd3aRa0Wk,11096
+better_notion-2.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+better_notion-2.1.0.dist-info/entry_points.txt,sha256=D0bUcP7Z00Zyjxw7r2p29T95UrwioDO0aGDoHe9I6fo,55
+better_notion-2.1.0.dist-info/licenses/LICENSE,sha256=BAdN3JpgMY_y_fWqZSCFSvSbC2mTHP-BKDAzF5FXQAI,1069
+better_notion-2.1.0.dist-info/RECORD,,