better-notion 0.9.4__tar.gz → 0.9.6__tar.gz

{better_notion-0.9.4 → better_notion-0.9.6}/PKG-INFO

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

@@ -183,40 +183,87 @@ def list_plugins(
     """
     List all installed and available plugins.
 
+    Shows both official plugins (built-in) and user-installed plugins.
+
     Examples:
         notion plugin list
         notion plugin list --verbose
         notion plugin list --json
     """
     try:
+        from better_notion.plugins.official import OFFICIAL_PLUGINS
+        from better_notion.plugins.state import PluginStateManager
+
         loader = get_plugin_loader()
-        plugins = loader.list_plugins()
+        state_manager = PluginStateManager()
+
+        # Get user plugins
+        user_plugins = loader.list_plugins()
+
+        # Get official plugins with their state
+        official_plugins = {}
+        for plugin_class in OFFICIAL_PLUGINS:
+            try:
+                plugin = plugin_class()
+                info = plugin.get_info()
+                plugin_name = info.get('name')
+
+                # Add state information
+                info['bundled'] = True
+                info['enabled'] = state_manager.is_enabled(plugin_name)
+
+                official_plugins[plugin_name] = info
+            except Exception:
+                # Skip plugins that fail to instantiate
+                continue
+
+        # Merge both
+        all_plugins = {**official_plugins, **user_plugins}
 
         if json_output:
-            return typer.echo(json.dumps(plugins, indent=2))
+            return typer.echo(json.dumps(all_plugins, indent=2))
 
-        # Display as table
-        if not plugins:
-            typer.echo("No plugins installed.")
+        # Display as formatted output
+        if not all_plugins:
+            typer.echo("No plugins found.")
             typer.echo(f"\nPlugins directory: {Path.home() / '.notion' / 'plugins'}")
             return
 
-        typer.echo("Installed Plugins:")
-        typer.echo("┌" + "─" * 50 + "┐")
+        typer.echo("Plugins:")
+        typer.echo("=" * 70)
 
-        for name, info in plugins.items():
-            official_marker = "✓" if info.get("official") else " "
-            typer.echo(f"│ {official_marker} {name:30} │ {info.get('description', 'No description'):40} │")
+        # Group by type
+        has_official = bool(official_plugins)
+        has_user = bool(user_plugins)
 
-            if verbose:
-                typer.echo(f"│   Version: {info.get('version', 'unknown'):20} │")
-                typer.echo(f"│   Author:  {info.get('author', 'unknown'):20} │")
-                typer.echo("│" + "─" * 50 + "│")
+        if has_official:
+            typer.echo("\nOfficial Plugins (built-in):")
+            for name, info in official_plugins.items():
+                enabled = info.get('enabled', True)
+                status = "✓ Enabled" if enabled else "✗ Disabled"
+                typer.echo(f"  • {name:20} {info.get('description', 'No description'):40} [{status}]")
+
+                if verbose:
+                    typer.echo(f"    Version: {info.get('version', 'unknown')}")
+                    typer.echo(f"    Author:  {info.get('author', 'unknown')}")
+                    if info.get('category'):
+                        typer.echo(f"    Category: {info.get('category')}")
+
+        if has_user:
+            if has_official:
+                typer.echo("\nUser Plugins:")
+            for name, info in user_plugins.items():
+                official_marker = "✓" if info.get("official") else " "
+                typer.echo(f"  • [{official_marker}] {name:20} {info.get('description', 'No description'):40}")
+
+                if verbose:
+                    typer.echo(f"    Version: {info.get('version', 'unknown')}")
+                    typer.echo(f"    Author:  {info.get('author', 'unknown')}")
 
-        typer.echo("└" + "─" * 50 + "┘")
+        typer.echo("\nTip: Use 'notion plugin enable/disable <name>' to toggle official plugins")
 
     except Exception as e:
-        return format_error("LIST_ERROR",  str(e))
+        return format_error("LIST_ERROR", str(e))
 
 
 @app.command()
@@ -476,14 +523,33 @@ def enable(
     """
     Enable a plugin.
 
+    For official plugins, this re-enables them if they were disabled.
+    For user plugins, this adds them to the enabled list.
+
     Examples:
+        notion plugin enable productivity
         notion plugin enable organizations
     """
-    # Create enabled plugins list
-    config_file = Path.home() / ".notion" / "plugins" / "enabled.json"
-    config_file.parent.mkdir(parents=True, exist_ok=True)
-
     try:
+        loader = get_plugin_loader()
+
+        # Check if it's an official plugin
+        if loader.is_official_plugin(plugin_name):
+            from better_notion.plugins.state import PluginStateManager
+
+            state_manager = PluginStateManager()
+            state_manager.enable(plugin_name)
+
+            return format_success({
+                "plugin": plugin_name,
+                "status": "enabled",
+                "type": "official"
+            })
+
+        # For user plugins, use the existing enabled.json logic
+        config_file = Path.home() / ".notion" / "plugins" / "enabled.json"
+        config_file.parent.mkdir(parents=True, exist_ok=True)
+
         if config_file.exists():
             config = json.loads(config_file.read_text())
         else:
@@ -495,11 +561,12 @@ def enable(
 
         return format_success({
             "plugin": plugin_name,
-            "status": "enabled"
+            "status": "enabled",
+            "type": "user"
         })
 
     except Exception as e:
-        return format_error("ENABLE_ERROR",  str(e))
+        return format_error("ENABLE_ERROR", str(e))
 
 
 @app.command()
@@ -509,25 +576,51 @@ def disable(
     """
     Disable a plugin.
 
+    For official plugins, this disables them (but doesn't remove them).
+    For user plugins, this removes them from the enabled list.
+
     Examples:
+        notion plugin disable productivity
         notion plugin disable organizations
     """
-    config_file = Path.home() / ".notion" / "plugins" / "enabled.json"
-
     try:
-        if config_file.exists():
-            config = json.loads(config_file.read_text())
-            if plugin_name in config.get("enabled", []):
-                config["enabled"].remove(plugin_name)
-                config_file.write_text(json.dumps(config, indent=2))
+        loader = get_plugin_loader()
 
-        return format_success({
-            "plugin": plugin_name,
-            "status": "disabled"
-        })
+        # Check if it's an official plugin
+        if loader.is_official_plugin(plugin_name):
+            from better_notion.plugins.state import PluginStateManager
+
+            state_manager = PluginStateManager()
+            state_manager.disable(plugin_name)
+
+            return format_success({
+                "plugin": plugin_name,
+                "status": "disabled",
+                "type": "official",
+                "message": "Plugin will be disabled after CLI restart"
+            })
+
+        # For user plugins, use the existing enabled.json logic
+        config_file = Path.home() / ".notion" / "plugins" / "enabled.json"
+
+        try:
+            if config_file.exists():
+                config = json.loads(config_file.read_text())
+                if plugin_name in config.get("enabled", []):
+                    config["enabled"].remove(plugin_name)
+                    config_file.write_text(json.dumps(config, indent=2))
+
+            return format_success({
+                "plugin": plugin_name,
+                "status": "disabled",
+                "type": "user"
+            })
+
+        except Exception as e:
+            return format_error("DISABLE_ERROR", str(e))
 
     except Exception as e:
-        return format_error("DISABLE_ERROR",  str(e))
+        return format_error("DISABLE_ERROR", str(e))
 
 
 @app.command()

{better_notion-0.9.4 → better_notion-0.9.6}/better_notion/_cli/commands/update.py

@@ -13,40 +13,19 @@ import typer
 from better_notion._cli.async_typer import AsyncTyper
 from better_notion._cli.response import format_error, format_success
 
-app = AsyncTyper(help="Update Better Notion CLI", invoke_without_command=True)
+app = AsyncTyper(help="Update Better Notion CLI", invoke_without_command=True, no_args_is_help=False)
 
 
-@app.callback()
-def main(
-    ctx: typer.Context,
-    check: bool = typer.Option(False, "--check", "-c", help="Only check if an update is available"),
-) -> None:
+def _perform_upgrade(check: bool = False) -> None:
     """
-    Update Better Notion CLI to the latest version.
+    Internal function to perform the upgrade.
 
-    If no subcommand is specified, performs an update by default.
-    """
-    # If no subcommand was provided, execute upgrade
-    if ctx.invoked_subcommand is None:
-        upgrade(check=check)
-
-
-@app.command()
-def upgrade(
-    check: bool = typer.Option(False, "--check", "-c", help="Only check if an update is available"),
-) -> None:
+    Args:
+        check: If True, only check for updates without installing
     """
-    Update Better Notion CLI to the latest version.
-
-    This is a simple wrapper around pip that checks for and installs updates.
-    pip handles all version checking, downloading, and dependency management.
+    import platform
+    import sys
 
-    Examples:
-        notion update                 # Install latest version (default)
-        notion update upgrade         # Same as above
-        notion update --check         # Check for updates only
-        notion update upgrade --check # Same as above
-    """
     package_name = "better-notion"
 
     if check:
@@ -85,6 +64,14 @@ def upgrade(
     else:
         # Perform the actual upgrade
         typer.echo(f"Updating {package_name} to the latest version...")
+
+        # Warn Windows users about potential file locking
+        if platform.system() == "Windows":
+            typer.echo("")
+            typer.echo("⚠ Note: On Windows, if you see a file access error,")
+            typer.echo("  close all terminals and run: pip install --upgrade better-notion")
+            typer.echo("")
+
         typer.echo("")
 
         try:
@@ -112,6 +99,40 @@ def upgrade(
             return format_error("UPDATE_ERROR", str(e))
 
 
+@app.callback()
+def main(
+    ctx: typer.Context,
+    check: bool = typer.Option(False, "--check", "-c", help="Only check if an update is available"),
+) -> None:
+    """
+    Update Better Notion CLI to the latest version.
+
+    If no subcommand is specified, performs an update by default.
+    """
+    # If no subcommand was provided, execute upgrade
+    if ctx.invoked_subcommand is None:
+        _perform_upgrade(check=check)
+
+
+@app.command()
+def upgrade(
+    check: bool = typer.Option(False, "--check", "-c", help="Only check if an update is available"),
+) -> None:
+    """
+    Update Better Notion CLI to the latest version.
+
+    This is a simple wrapper around pip that checks for and installs updates.
+    pip handles all version checking, downloading, and dependency management.
+
+    Examples:
+        notion update                 # Install latest version (default)
+        notion update upgrade         # Same as above
+        notion update --check         # Check for updates only
+        notion update upgrade --check # Same as above
+    """
+    _perform_upgrade(check=check)
+
+
 @app.command()
 def check() -> None:
     """
@@ -122,7 +143,7 @@ def check() -> None:
     Examples:
         notion update check
     """
-    upgrade(check=True)
+    _perform_upgrade(check=True)
 
 
 @app.command()
@@ -135,4 +156,4 @@ def self() -> None:
     Examples:
         notion update self
     """
-    upgrade(check=False)
+    _perform_upgrade(check=False)

{better_notion-0.9.4 → better_notion-0.9.6}/better_notion/_cli/main.py

@@ -41,22 +41,33 @@ app.add_typer(update.app, name="update")
 
 # Load and register official plugins
 def _load_official_plugins():
-    """Load and register official plugins."""
+    """Load and register official plugins, respecting their enabled/disabled state."""
     try:
         from better_notion.plugins.official import OFFICIAL_PLUGINS
         from better_notion.plugins.loader import PluginLoader
+        from better_notion.plugins.state import PluginStateManager
 
         loader = PluginLoader()
+        state_manager = PluginStateManager()
 
         for plugin_class in OFFICIAL_PLUGINS:
             try:
                 plugin = plugin_class()
-                plugin.register_commands(app)
                 info = plugin.get_info()
+                plugin_name = info.get('name')
+
+                # Check if plugin is disabled
+                if not state_manager.is_enabled(plugin_name):
+                    # Skip loading this plugin
+                    continue
+
+                # Register the plugin's commands
+                plugin.register_commands(app)
+
                 # Store plugin for later reference
                 if not hasattr(app, '_loaded_plugins'):
                     app._loaded_plugins = {}
-                app._loaded_plugins[info['name']] = plugin
+                app._loaded_plugins[plugin_name] = plugin
             except Exception as e:
                 # Log but don't fail if a plugin fails to load
                 pass

better_notion-0.9.6/better_notion/plugins/state.py

@@ -0,0 +1,123 @@
+"""
+Plugin state management for Better Notion CLI.
+
+This module handles the state of official plugins (enabled/disabled).
+"""
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+class PluginStateManager:
+    """Manages the enabled/disabled state of official plugins."""
+
+    def __init__(self, state_file: Path | None = None):
+        """
+        Initialize the plugin state manager.
+
+        Args:
+            state_file: Path to the state file. Defaults to ~/.notion/plugins/state.json
+        """
+        self.state_file = state_file or (Path.home() / ".notion" / "plugins" / "state.json")
+        self.state_file.parent.mkdir(parents=True, exist_ok=True)
+        self._state = self._load_state()
+
+    def _load_state(self) -> dict[str, Any]:
+        """Load state from file."""
+        if self.state_file.exists():
+            try:
+                return json.loads(self.state_file.read_text())
+            except (json.JSONDecodeError, IOError):
+                pass
+        return {"official_plugins": {}}
+
+    def _save_state(self) -> None:
+        """Save state to file."""
+        self.state_file.write_text(json.dumps(self._state, indent=2))
+
+    def is_enabled(self, plugin_name: str) -> bool:
+        """
+        Check if a plugin is enabled.
+
+        Args:
+            plugin_name: Name of the plugin
+
+        Returns:
+            True if the plugin is enabled, False if disabled
+        """
+        plugin_state = self._state.get("official_plugins", {}).get(plugin_name, {})
+        return plugin_state.get("state") != "disabled"
+
+    def enable(self, plugin_name: str) -> None:
+        """
+        Enable a plugin.
+
+        Args:
+            plugin_name: Name of the plugin to enable
+        """
+        if "official_plugins" not in self._state:
+            self._state["official_plugins"] = {}
+
+        # Remove disabled state if it exists
+        if plugin_name in self._state["official_plugins"]:
+            del self._state["official_plugins"][plugin_name]
+
+        self._save_state()
+
+    def disable(self, plugin_name: str) -> None:
+        """
+        Disable a plugin.
+
+        Args:
+            plugin_name: Name of the plugin to disable
+        """
+        if "official_plugins" not in self._state:
+            self._state["official_plugins"] = {}
+
+        self._state["official_plugins"][plugin_name] = {
+            "state": "disabled",
+            "disabled_at": datetime.now().isoformat()
+        }
+
+        self._save_state()
+
+    def get_plugin_state(self, plugin_name: str) -> dict[str, Any] | None:
+        """
+        Get the state of a specific plugin.
+
+        Args:
+            plugin_name: Name of the plugin
+
+        Returns:
+            Plugin state dict or None if no state exists
+        """
+        return self._state.get("official_plugins", {}).get(plugin_name)
+
+    def get_all_states(self) -> dict[str, dict[str, Any]]:
+        """
+        Get states of all plugins.
+
+        Returns:
+            Dict mapping plugin names to their states
+        """
+        return self._state.get("official_plugins", {})
+
+    def is_official_plugin(self, plugin_name: str) -> bool:
+        """
+        Check if a plugin is an official plugin.
+
+        This is a helper that can be used to determine if a plugin
+        should be managed through the state system.
+
+        Args:
+            plugin_name: Name of the plugin
+
+        Returns:
+            True if the plugin is official
+        """
+        # This will be checked against the OFFICIAL_PLUGINS list
+        # For now, return False - the actual check is done elsewhere
+        return False

{better_notion-0.9.4 → better_notion-0.9.6}/pyproject.toml

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