better-notion 1.5.3__tar.gz → 1.5.5__tar.gz

{better_notion-1.5.3 → better_notion-1.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: better-notion
-Version: 1.5.3
+Version: 1.5.5
 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-1.5.3 → better_notion-1.5.5}/better_notion/_cli/commands/pages.py

@@ -390,7 +390,7 @@ async def clear(page_id: str) -> None:
     deleted_count = 0
     for block_id in block_ids:
         try:
-            await client.api.blocks.delete(block_id)
+            await client.api._request("DELETE", f"/blocks/{block_id}")
             deleted_count += 1
         except Exception:
             # Continue even if deletion fails

{better_notion-1.5.3 → better_notion-1.5.5}/better_notion/_sdk/models/page.py

@@ -522,9 +522,10 @@ class Page(BaseEntity):
             if cursor:
                 params["start_cursor"] = cursor
 
-            return await self._client.api.blocks.children.list(
-                block_id=self.id,
-                **params
+            return await self._client.api._request(
+                "GET",
+                f"/blocks/{self.id}/children",
+                params=params
             )
 
         # Define item parser

{better_notion-1.5.3 → better_notion-1.5.5}/better_notion/plugins/official/agents.py

@@ -86,6 +86,18 @@ class AgentsPlugin(CombinedPluginInterface):
                 "-n",
                 help="Name for the workspace",
             ),
+            reset: bool = typer.Option(
+                False,
+                "--reset",
+                "-r",
+                help="Reset workspace (delete existing databases and recreate)",
+            ),
+            skip: bool = typer.Option(
+                False,
+                "--skip",
+                "-s",
+                help="Skip if workspace already exists (return existing databases)",
+            ),
             debug: bool = typer.Option(
                 False,
                 "--debug",
@@ -106,8 +118,13 @@ class AgentsPlugin(CombinedPluginInterface):
             - Incidents
             - Tags
 
+            If a workspace already exists in the page, use --reset to recreate
+            or --skip to keep the existing one.
+
             Example:
                 $ notion agents init --parent-page page123 --name "My Workspace"
+                $ notion agents init --parent-page page123 --reset  # Recreate
+                $ notion agents init --parent-page page123 --skip    # Keep existing
             """
             import asyncio
             import logging
@@ -128,17 +145,40 @@ class AgentsPlugin(CombinedPluginInterface):
                     client = get_client()
                     initializer = WorkspaceInitializer(client)
 
+                    # Handle --skip flag
+                    if skip:
+                        from better_notion._sdk.models.page import Page
+                        from better_notion.utils.agents.metadata import WorkspaceMetadata
+
+                        try:
+                            page = await Page.get(parent_page_id, client=client)
+                            existing = await WorkspaceMetadata.detect_workspace(page, client)
+
+                            if existing:
+                                database_ids = existing.get("database_ids", {})
+                                return format_success(
+                                    {
+                                        "message": "Workspace already exists, skipping initialization",
+                                        "workspace_id": existing.get("workspace_id"),
+                                        "databases_found": len(database_ids),
+                                        "database_ids": database_ids,
+                                    }
+                                )
+                        except Exception:
+                            # If detection fails, proceed with normal init
+                            pass
+
+                    # Initialize workspace (with skip_detection=True if --reset)
                     database_ids = await initializer.initialize_workspace(
                         parent_page_id=parent_page_id,
                         workspace_name=workspace_name,
+                        skip_detection=reset,  # Skip detection if resetting
                     )
 
-                    # Save database IDs
-                    initializer.save_database_ids()
-
                     return format_success(
                         {
                             "message": "Workspace initialized successfully",
+                            "workspace_id": initializer._workspace_id,
                             "databases_created": len(database_ids),
                             "database_ids": database_ids,
                         }
@@ -151,6 +191,81 @@ class AgentsPlugin(CombinedPluginInterface):
             result = asyncio.run(_init())
             typer.echo(result)
 
+        @agents_app.command("info")
+        def workspace_info(
+            parent_page_id: str = typer.Option(
+                ...,
+                "--parent-page",
+                "-p",
+                help="ID of the parent page to check",
+            ),
+        ) -> None:
+            """
+            Show workspace information for a page.
+
+            Displays whether a workspace is initialized in the given page,
+            along with workspace metadata and database information.
+
+            Example:
+                $ notion agents info --parent-page page123
+            """
+            import asyncio
+
+            async def _info() -> str:
+                try:
+                    client = get_client()
+                    from better_notion._sdk.models.page import Page
+                    from better_notion.utils.agents.metadata import WorkspaceMetadata
+
+                    page = await Page.get(parent_page_id, client=client)
+                    existing = await WorkspaceMetadata.detect_workspace(page, client)
+
+                    if existing:
+                        database_ids = existing.get("database_ids", {})
+
+                        return format_success(
+                            {
+                                "message": "Workspace found in this page",
+                                "parent_page": parent_page_id,
+                                "parent_title": page.title,
+                                "workspace_id": existing.get("workspace_id"),
+                                "workspace_name": existing.get("workspace_name"),
+                                "initialized_at": existing.get("initialized_at"),
+                                "databases_count": len(database_ids),
+                                "database_ids": database_ids,
+                                "detection_method": existing.get("detection_method", "config_file"),
+                            }
+                        )
+                    else:
+                        # Search for any databases in the page
+                        results = await client.search(
+                            query="",
+                            filter={"value": "database", "property": "object"}
+                        )
+
+                        # Count databases in this page
+                        databases_in_page = []
+                        for result in results:
+                            if hasattr(result, 'title'):
+                                databases_in_page.append(result.title)
+
+                        return format_success(
+                            {
+                                "message": "No agents workspace found in this page",
+                                "parent_page": parent_page_id,
+                                "parent_title": page.title,
+                                "workspace_initialized": False,
+                                "other_databases": len(databases_in_page),
+                            }
+                        )
+
+                except Exception as e:
+                    result = format_error("INFO_ERROR", str(e), retry=False)
+                    return result
+
+            result = asyncio.run(_info())
+            typer.echo(result)
+
         @agents_app.command("init-project")
         def init_project(
             project_id: str = typer.Option(

better_notion-1.5.5/better_notion/utils/agents/metadata.py

@@ -0,0 +1,185 @@
+"""Workspace metadata management for agents plugin.
+
+This module provides functionality to manage workspace metadata,
+including detecting duplicate workspaces and storing workspace information.
+"""
+
+import json
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+from uuid import uuid4
+
+from better_notion._sdk.client import NotionClient
+from better_notion._sdk.models.page import Page
+
+logger = logging.getLogger(__name__)
+
+
+class WorkspaceMetadata:
+    """Manage workspace metadata for duplicate detection."""
+
+    # Property names used in Notion page
+    PROP_WORKSPACE_ID = "agents_workspace_id"
+    PROP_WORKSPACE_NAME = "agents_workspace_name"
+    PROP_INITIALIZED_AT = "agents_workspace_created"
+    PROP_VERSION = "agents_workspace_version"
+    PROP_DATABASE_IDS = "agents_workspace_databases"
+
+    @staticmethod
+    def generate_workspace_id() -> str:
+        """Generate a unique workspace ID.
+
+        Returns:
+            Unique workspace ID (UUID without hyphens for compactness)
+        """
+        return str(uuid4()).replace("-", "")
+
+    @staticmethod
+    def extract_metadata_from_page(page: Page) -> dict[str, Any]:
+        """Extract workspace metadata from page properties.
+
+        Args:
+            page: Page object to extract metadata from
+
+        Returns:
+            Dict with workspace metadata (empty if not initialized)
+
+        Example:
+            >>> metadata = WorkspaceMetadata.extract_metadata_from_page(page)
+            >>> if metadata.get("workspace_id"):
+            ...     print(f"Workspace: {metadata['workspace_name']}")
+        """
+        metadata = {}
+
+        # Try to get workspace ID from icon (stored as emoji)
+        # Notion doesn't support custom properties, so we use creative approaches
+
+        # Check if page icon contains our metadata marker
+        icon = page.icon
+        if icon and icon.startswith("🤖"):
+            metadata["is_agents_workspace"] = True
+            # Could encode data in icon, but keep it simple for now
+
+        return metadata
+
+    @staticmethod
+    async def detect_workspace(
+        page: Page,
+        client: NotionClient
+    ) -> dict[str, Any] | None:
+        """Detect if page already has an agents workspace.
+
+        Args:
+            page: Parent page to check
+            client: NotionClient instance
+
+        Returns:
+            Workspace metadata dict if found, None otherwise
+        """
+        # Primary detection: Scan for databases with expected names
+        expected_databases = [
+            "Organizations",
+            "Tags",
+            "Projects",
+            "Versions",
+            "Tasks",
+            "Ideas",
+            "Work Issues",
+            "Incidents"
+        ]
+
+        try:
+            # Search for databases in this page
+            results = await client.search(
+                query="",
+                filter={"value": "database", "property": "object"}
+            )
+
+            databases_found = []
+            database_ids = {}
+
+            for result in results:
+                if hasattr(result, 'title') and result.title in expected_databases:
+                    databases_found.append(result.title)
+                    # Extract the key name (lowercase with underscores)
+                    key = result.title.lower().replace(" ", "_")
+                    database_ids[key] = result.id
+
+            # Check if we have at least 5 of the expected databases
+            matches = len(databases_found)
+            if matches >= 5:
+                logger.info(f"Detected existing workspace with {matches}/{len(expected_databases)} databases in page {page.id}")
+
+                # Try to load workspace metadata from local config to get workspace_id
+                workspace_id = None
+                workspace_name = None
+                initialized_at = None
+
+                try:
+                    config_path = Path.home() / ".notion" / "workspace.json"
+                    if config_path.exists():
+                        with open(config_path, "r", encoding="utf-8") as f:
+                            config = json.load(f)
+                            # Only use config if it matches this page
+                            if config.get("parent_page") == page.id:
+                                workspace_id = config.get("workspace_id")
+                                workspace_name = config.get("workspace_name")
+                                initialized_at = config.get("initialized_at")
+                                logger.info(f"Config file matches this page, workspace_id: {workspace_id}")
+                except Exception as e:
+                    logger.debug(f"Could not load local config: {e}")
+
+                return {
+                    "workspace_id": workspace_id,
+                    "workspace_name": workspace_name,
+                    "initialized_at": initialized_at,
+                    "database_ids": database_ids,
+                    "detection_method": "database_scan",
+                    "databases_count": matches
+                }
+        except Exception as e:
+            logger.debug(f"Could not scan for databases: {e}")
+
+        return None
+
+    @staticmethod
+    def save_workspace_config(
+        page_id: str,
+        workspace_id: str,
+        workspace_name: str,
+        database_ids: dict[str, str],
+        path: Optional[Path] = None
+    ) -> Path:
+        """Save workspace configuration to local file.
+
+        Args:
+            page_id: Parent page ID
+            workspace_id: Unique workspace ID
+            workspace_name: Workspace name
+            database_ids: Dict of database name to ID
+            path: Optional custom path for config file
+
+        Returns:
+            Path to saved config file
+        """
+        if path is None:
+            path = Path.home() / ".notion" / "workspace.json"
+
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        config = {
+            "workspace_id": workspace_id,
+            "workspace_name": workspace_name,
+            "parent_page": page_id,
+            "initialized_at": datetime.now(timezone.utc).isoformat(),
+            "version": "1.5.4",  # Track version for migrations
+            "database_ids": database_ids
+        }
+
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(config, f, indent=2)
+
+        logger.info(f"Saved workspace config to {path}")
+        return path

{better_notion-1.5.3 → better_notion-1.5.5}/better_notion/utils/agents/workspace.py

@@ -6,12 +6,14 @@ required databases for the workflow management system.
 
 import json
 import logging
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Optional
 
 from better_notion._cli.config import Config
 from better_notion._sdk.client import NotionClient
 from better_notion._sdk.models.page import Page
+from better_notion.utils.agents.metadata import WorkspaceMetadata
 from better_notion.utils.agents.schemas import (
     IncidentSchema,
     IdeaSchema,
@@ -48,11 +50,15 @@ class WorkspaceInitializer:
         """
         self._client = client
         self._database_ids: Dict[str, str] = {}
+        self._workspace_id: Optional[str] = None
+        self._parent_page_id: Optional[str] = None
+        self._workspace_name: Optional[str] = None
 
     async def initialize_workspace(
         self,
         parent_page_id: str,
         workspace_name: str = "Agents Workspace",
+        skip_detection: bool = False,
     ) -> Dict[str, str]:
         """Initialize a complete workspace with all databases.
 
@@ -62,15 +68,22 @@ class WorkspaceInitializer:
         Args:
             parent_page_id: ID of the parent page where databases will be created
             workspace_name: Name for the workspace (used for database titles)
+            skip_detection: If True, skip duplicate detection (for reset operation)
 
         Returns:
             Dict mapping database names to their IDs
 
         Raises:
             Exception: If database creation fails with detailed error message
+            Exception: If workspace already exists (and skip_detection is False)
         """
         logger.info(f"Initializing workspace '{workspace_name}' in page {parent_page_id}")
 
+        # Store workspace info
+        self._parent_page_id = parent_page_id
+        self._workspace_name = workspace_name
+        self._workspace_id = WorkspaceMetadata.generate_workspace_id()
+
         # Get parent page
         try:
             parent = await Page.get(parent_page_id, client=self._client)
@@ -80,6 +93,26 @@ class WorkspaceInitializer:
             logger.error(error_msg)
             raise Exception(error_msg) from e
 
+        # Check for existing workspace unless skipped
+        if not skip_detection:
+            existing = await WorkspaceMetadata.detect_workspace(parent, self._client)
+            if existing:
+                workspace_info = {
+                    "workspace_id": existing.get("workspace_id", "unknown"),
+                    "workspace_name": existing.get("workspace_name", workspace_name),
+                    "initialized_at": existing.get("initialized_at", "unknown"),
+                    "databases": existing.get("database_ids", {})
+                }
+                error_msg = (
+                    f"Workspace already initialized in this page\n"
+                    f"Workspace ID: {workspace_info['workspace_id']}\n"
+                    f"Initialized: {workspace_info['initialized_at']}\n"
+                    f"Databases: {len(workspace_info.get('databases', {}))} created\n"
+                    f"Use --reset to reinitialize or --skip to keep existing"
+                )
+                logger.error(error_msg)
+                raise Exception(error_msg) from None
+
         # Create databases in order (independent first, then dependent)
         self._database_ids = {}
         databases_order = [
@@ -108,7 +141,11 @@ class WorkspaceInitializer:
                 logger.error(error_msg)
                 raise Exception(error_msg) from e
 
+        # Save workspace metadata
+        self.save_database_ids()
+
         logger.info(f"Workspace initialization complete. Created {len(self._database_ids)} databases")
+        logger.info(f"Workspace ID: {self._workspace_id}")
         return self._database_ids
 
     async def _create_organizations_db(self, parent: Page) -> None:
@@ -312,7 +349,7 @@ class WorkspaceInitializer:
         pass
 
     def save_database_ids(self, path: Optional[Path] = None) -> None:
-        """Save database IDs to a config file.
+        """Save workspace metadata (database IDs and workspace info) to config file.
 
         Args:
             path: Path to save config file (default: ~/.notion/workspace.json)
@@ -322,8 +359,18 @@ class WorkspaceInitializer:
 
         path.parent.mkdir(parents=True, exist_ok=True)
 
+        # Save full workspace metadata
+        config = {
+            "workspace_id": self._workspace_id,
+            "workspace_name": self._workspace_name,
+            "parent_page": self._parent_page_id,
+            "initialized_at": datetime.now(timezone.utc).isoformat(),
+            "version": "1.5.4",
+            "database_ids": self._database_ids
+        }
+
         with open(path, "w", encoding="utf-8") as f:
-            json.dump(self._database_ids, f, indent=2)
+            json.dump(config, f, indent=2)
 
     @classmethod
     def load_database_ids(cls, path: Optional[Path] = None) -> Dict[str, str]:

{better_notion-1.5.3 → better_notion-1.5.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "better-notion"
-version = "1.5.3"
+version = "1.5.5"
 description = "A high-level Python SDK for the Notion API with developer experience in mind."
 readme = "README.md"
 requires-python = ">=3.10"