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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: better-notion
-Version: 0.9.6
+Version: 0.9.7
 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
@@ -25,6 +25,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: httpx<0.28.0,>=0.27.0
 Requires-Dist: pydantic<3.0.0,>=2.0.0
+Requires-Dist: rich<14.0.0,>=13.0.0
 Requires-Dist: typing-extensions>=4.0.0
 Provides-Extra: all
 Requires-Dist: asyncer>=0.0.5; extra == 'all'

better_notion-0.9.7/better_notion/_cli/commands/auth.py

@@ -0,0 +1,136 @@
+"""
+Authentication commands for Better Notion CLI.
+
+This module provides commands for managing authentication tokens.
+"""
+from __future__ import annotations
+
+import typer
+
+from better_notion._cli.async_typer import AsyncTyper
+from better_notion._cli.config import Config
+from better_notion._cli.display import is_human_mode, print_rich_error, print_rich_success
+
+app = AsyncTyper(help="Authentication commands")
+
+
+@app.command()
+def login(
+    ctx: typer.Context,
+    token: str = typer.Option(
+        ...,
+        "--token",
+        "-t",
+        help="Notion API integration token",
+        prompt=True,
+        hide_input=True,
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        "-j",
+        help="Output in JSON format (for AI agents)",
+    ),
+) -> None:
+    """
+    Authenticate with Notion API.
+
+    Stores the authentication token for subsequent CLI commands.
+    The token can be obtained from https://www.notion.so/my-integrations.
+    """
+    config_path = Config.get_config_path()
+
+    # Check if already logged in
+    if config_path.exists():
+        typer.confirm(
+            "You are already authenticated. Overwrite existing credentials?",
+            abort=True,
+        )
+
+    # Save the token
+    try:
+        Config.save(token=token)
+        print_rich_success(
+            "Successfully authenticated with Notion API",
+            data={"config_path": str(config_path)},
+            json_output=json_output and not is_human_mode()
+        )
+    except OSError as e:
+        print_rich_error(
+            f"Failed to save credentials: {e}",
+            details={"config_path": str(config_path)},
+            json_output=json_output and not is_human_mode()
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def status(
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        "-j",
+        help="Output in JSON format (for AI agents)",
+    ),
+) -> None:
+    """
+    Check authentication status.
+
+    Verifies the stored authentication token and displays workspace information.
+    """
+    from better_notion._cli.display import print_rich_info
+
+    config = Config.load()
+
+    info = {
+        "status": "authenticated",
+        "token_preview": config.token[:20] + "...",
+        "timeout": config.timeout,
+        "retry_attempts": config.retry_attempts,
+    }
+
+    print_rich_info(
+        info,
+        title="Authentication Status",
+        json_output=json_output and not is_human_mode()
+    )
+
+
+@app.command()
+def logout(
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        "-j",
+        help="Output in JSON format (for AI agents)",
+    ),
+) -> None:
+    """
+    Remove stored credentials.
+
+    Deletes the authentication token from the configuration file.
+    """
+    from better_notion._cli.display import print_rich_error
+
+    config_path = Config.get_config_path()
+
+    if not config_path.exists():
+        print_rich_error(
+            "No credentials found",
+            details={"config_path": str(config_path)},
+            json_output=json_output and not is_human_mode()
+        )
+        raise typer.Exit(1)
+
+    try:
+        config_path.unlink()
+        print_rich_success(
+            f"Credentials removed from {config_path}",
+            json_output=json_output and not is_human_mode()
+        )
+    except OSError as e:
+        print_rich_error(
+            f"Failed to remove credentials: {e}",
+            json_output=json_output and not is_human_mode()
+        )
+        raise typer.Exit(1)

better_notion-0.9.7/better_notion/_cli/commands/config.py

@@ -0,0 +1,178 @@
+"""
+Config commands for Better Notion CLI.
+
+This module provides commands for managing CLI configuration.
+"""
+from __future__ import annotations
+
+import json
+
+import typer
+
+from better_notion._cli.async_typer import AsyncTyper
+from better_notion._cli.config import Config
+from better_notion._cli.display import is_human_mode, print_rich_error, print_rich_info, print_rich_success
+
+app = AsyncTyper(help="Configuration commands")
+
+
+@app.command("get")
+def get(
+    key: str = typer.Argument(..., help="Configuration key to get"),
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+) -> None:
+    """Get a configuration value."""
+    use_json = json_output or not is_human_mode()
+
+    try:
+        config = Config.load()
+
+        valid_keys = ["token", "default_database", "default_output", "timeout", "retry_attempts"]
+
+        if key not in valid_keys:
+            print_rich_error(
+                f"Invalid key. Valid keys: {', '.join(valid_keys)}",
+                code="INVALID_KEY",
+                json_output=use_json
+            )
+            raise typer.Exit(1)
+
+        value = getattr(config, key, None)
+
+        # Mask token for security
+        if key == "token" and value:
+            value = value[:20] + "..."
+
+        print_rich_info(
+            {"key": key, "value": value},
+            title="Configuration Value",
+            json_output=use_json
+        )
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        print_rich_error(
+            f"Failed to get configuration: {e}",
+            code="UNKNOWN_ERROR",
+            json_output=use_json
+        )
+        raise typer.Exit(1)
+
+
+@app.command("set")
+def set(
+    key: str = typer.Argument(..., help="Configuration key to set"),
+    value: str = typer.Argument(..., help="Value to set"),
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+) -> None:
+    """Set a configuration value."""
+    use_json = json_output or not is_human_mode()
+
+    try:
+        config_path = Config.get_config_path()
+
+        # Load existing config
+        if config_path.exists():
+            with open(config_path) as f:
+                config_data = json.load(f)
+        else:
+            config_data = {}
+
+        # Parse value based on type
+        parsed_value = value
+        if key == "timeout" or key == "retry_attempts":
+            parsed_value = int(value)
+        elif key == "token" or key == "default_database" or key == "default_output":
+            pass  # Keep as string
+
+        config_data[key] = parsed_value
+
+        # Save updated config
+        with open(config_path, "w") as f:
+            json.dump(config_data, f, indent=2)
+
+        print_rich_success(
+            f"Configuration '{key}' set to {parsed_value}",
+            data={"key": key, "value": parsed_value},
+            json_output=use_json
+        )
+
+    except ValueError:
+        print_rich_error(
+            f"Invalid value for '{key}'. Expected type: int for timeout/retry_attempts",
+            code="INVALID_VALUE",
+            json_output=use_json
+        )
+        raise typer.Exit(1)
+    except Exception as e:
+        print_rich_error(
+            f"Failed to set configuration: {e}",
+            code="UNKNOWN_ERROR",
+            json_output=use_json
+        )
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_all(
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+) -> None:
+    """List all configuration values."""
+    use_json = json_output or not is_human_mode()
+
+    try:
+        from better_notion._cli.display import print_rich_table
+
+        config = Config.load()
+
+        config_data = [
+            {"key": "token", "value": config.token[:20] + "..." if config.token else None},
+            {"key": "default_database", "value": config.default_database},
+            {"key": "default_output", "value": config.default_output},
+            {"key": "timeout", "value": config.timeout},
+            {"key": "retry_attempts", "value": config.retry_attempts},
+        ]
+
+        print_rich_table(
+            config_data,
+            title="Configuration",
+            columns=["key", "value"],
+            json_output=use_json
+        )
+
+    except Exception as e:
+        print_rich_error(
+            f"Failed to list configuration: {e}",
+            code="UNKNOWN_ERROR",
+            json_output=use_json
+        )
+        raise typer.Exit(1)
+
+
+@app.command("reset")
+def reset(
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+) -> None:
+    """Reset configuration to defaults."""
+    use_json = json_output or not is_human_mode()
+
+    try:
+        config_path = Config.get_config_path()
+
+        if config_path.exists():
+            config_path.unlink()
+
+        print_rich_success(
+            "Configuration has been reset. Run 'notion auth login' to configure.",
+            data={"status": "reset"},
+            json_output=use_json
+        )
+
+    except Exception as e:
+        print_rich_error(
+            f"Failed to reset configuration: {e}",
+            code="UNKNOWN_ERROR",
+            json_output=use_json
+        )
+        raise typer.Exit(1)

{better_notion-0.9.6 → better_notion-0.9.7}/better_notion/_cli/commands/plugins.py

@@ -25,7 +25,12 @@ import typer
 from typer.testing import CliRunner
 
 from better_notion._cli.async_typer import AsyncTyper
-from better_notion._cli.response import format_error, format_success
+from better_notion._cli.display import (
+    is_human_mode,
+    print_rich_error,
+    print_rich_success,
+    print_rich_table,
+)
 from better_notion.plugins.loader import PluginLoader
 from better_notion.plugins.base import CommandPlugin
 
@@ -220,7 +225,10 @@ def list_plugins(
         # Merge both
         all_plugins = {**official_plugins, **user_plugins}
 
-        if json_output:
+        # Determine output mode
+        use_json = json_output or not is_human_mode()
+
+        if use_json:
             return typer.echo(json.dumps(all_plugins, indent=2))
 
         # Display as formatted output
@@ -229,41 +237,49 @@ def list_plugins(
             typer.echo(f"\nPlugins directory: {Path.home() / '.notion' / 'plugins'}")
             return
 
-        typer.echo("Plugins:")
-        typer.echo("=" * 70)
-
-        # Group by type
-        has_official = bool(official_plugins)
-        has_user = bool(user_plugins)
-
-        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')}")
+        # Build table data for Rich display
+        table_data = []
+        for name, info in all_plugins.items():
+            is_bundled = info.get('bundled', False)
+            enabled = info.get('enabled', True) if is_bundled else True
+
+            status = "✓ Enabled" if enabled else "✗ Disabled"
+            if not is_bundled:
+                status = "User"
+
+            row = {
+                "name": name,
+                "description": info.get('description', 'No description')[:40],
+                "status": status,
+            }
+
+            if verbose:
+                row["version"] = info.get('version', 'unknown')
+                row["author"] = info.get('author', 'unknown')
+
+            table_data.append(row)
 
+        # Display table
+        columns = ["name", "description", "status"]
+        if verbose:
+            columns.extend(["version", "author"])
+
+        print_rich_table(
+            table_data,
+            title=f"Plugins ({len(all_plugins)} total)",
+            columns=columns,
+            json_output=False
+        )
+
+        # Show tip
         typer.echo("\nTip: Use 'notion plugin enable/disable <name>' to toggle official plugins")
 
     except Exception as e:
-        return format_error("LIST_ERROR", str(e))
+        print_rich_error(
+            f"Failed to list plugins: {e}",
+            code="LIST_ERROR",
+            json_output=json_output or not is_human_mode()
+        )
 
 
 @app.command()
@@ -519,6 +535,7 @@ def validate(
 @app.command()
 def enable(
     plugin_name: str = typer.Argument(..., help="Name of the plugin to enable"),
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
 ) -> None:
     """
     Enable a plugin.
@@ -540,11 +557,13 @@ def enable(
             state_manager = PluginStateManager()
             state_manager.enable(plugin_name)
 
-            return format_success({
-                "plugin": plugin_name,
-                "status": "enabled",
-                "type": "official"
-            })
+            use_json = json_output or not is_human_mode()
+            print_rich_success(
+                f"Plugin '{plugin_name}' enabled (may require CLI restart)",
+                data={"plugin": plugin_name, "type": "official"},
+                json_output=use_json
+            )
+            return
 
         # For user plugins, use the existing enabled.json logic
         config_file = Path.home() / ".notion" / "plugins" / "enabled.json"
@@ -559,19 +578,26 @@ def enable(
             config["enabled"].append(plugin_name)
             config_file.write_text(json.dumps(config, indent=2))
 
-        return format_success({
-            "plugin": plugin_name,
-            "status": "enabled",
-            "type": "user"
-        })
+        use_json = json_output or not is_human_mode()
+        print_rich_success(
+            f"Plugin '{plugin_name}' enabled",
+            data={"plugin": plugin_name, "type": "user"},
+            json_output=use_json
+        )
 
     except Exception as e:
-        return format_error("ENABLE_ERROR", str(e))
+        use_json = json_output or not is_human_mode()
+        print_rich_error(
+            f"Failed to enable plugin: {e}",
+            code="ENABLE_ERROR",
+            json_output=use_json
+        )
 
 
 @app.command()
 def disable(
     plugin_name: str = typer.Argument(..., help="Name of the plugin to disable"),
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
 ) -> None:
     """
     Disable a plugin.
@@ -593,12 +619,13 @@ def disable(
             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"
-            })
+            use_json = json_output or not is_human_mode()
+            print_rich_success(
+                f"Plugin '{plugin_name}' disabled (will take effect after CLI restart)",
+                data={"plugin": plugin_name, "type": "official"},
+                json_output=use_json
+            )
+            return
 
         # For user plugins, use the existing enabled.json logic
         config_file = Path.home() / ".notion" / "plugins" / "enabled.json"
@@ -610,17 +637,28 @@ def disable(
                     config["enabled"].remove(plugin_name)
                     config_file.write_text(json.dumps(config, indent=2))
 
-            return format_success({
-                "plugin": plugin_name,
-                "status": "disabled",
-                "type": "user"
-            })
+            use_json = json_output or not is_human_mode()
+            print_rich_success(
+                f"Plugin '{plugin_name}' disabled",
+                data={"plugin": plugin_name, "type": "user"},
+                json_output=use_json
+            )
 
         except Exception as e:
-            return format_error("DISABLE_ERROR", str(e))
+            use_json = json_output or not is_human_mode()
+            print_rich_error(
+                f"Failed to disable plugin: {e}",
+                code="DISABLE_ERROR",
+                json_output=use_json
+            )
 
     except Exception as e:
-        return format_error("DISABLE_ERROR", str(e))
+        use_json = json_output or not is_human_mode()
+        print_rich_error(
+            f"Failed to disable plugin: {e}",
+            code="DISABLE_ERROR",
+            json_output=use_json
+        )
 
 
 @app.command()
@@ -702,8 +740,10 @@ def marketplace(
         if category:
             plugins_data = [p for p in plugins_data if p.get("category") == category]
 
-        # Output as JSON if requested
-        if json_output:
+        # Determine output mode
+        use_json = json_output or not is_human_mode()
+
+        if use_json:
             return typer.echo(json.dumps({"plugins": plugins_data}, indent=2))
 
         # Display in formatted table
@@ -714,42 +754,50 @@ def marketplace(
                 typer.echo("No official plugins available.")
             return
 
-        typer.echo("Official Plugins Marketplace")
-        typer.echo("=" * 70)
-        typer.echo(f"Found {len(plugins_data)} official plugin(s)")
-        typer.echo()
-
-        for idx, info in enumerate(plugins_data, 1):
-            typer.echo(f"{idx}. {info.get('name', 'unknown')}")
-            typer.echo(f"   {info.get('description', 'No description')}")
-
-            # Always show basic info
-            typer.echo(f"   Version: {info.get('version', 'unknown'):8} │ "
-                      f"Author: {info.get('author', 'unknown')}")
+        # Build table data for Rich
+        table_data = []
+        for info in plugins_data:
+            row = {
+                "name": info.get('name', 'unknown'),
+                "description": info.get('description', 'No description')[:40],
+                "version": info.get('version', 'unknown'),
+            }
 
             if verbose:
-                # Show additional details in verbose mode
+                row["author"] = info.get('author', 'unknown')
                 if info.get("category"):
-                    typer.echo(f"   Category: {info.get('category')}")
-                if info.get("dependencies"):
-                    deps = info.get("dependencies", [])
-                    if deps:
-                        typer.echo(f"   Dependencies: {', '.join(deps)}")
-                    else:
-                        typer.echo(f"   Dependencies: None")
-                if info.get("official"):
-                    typer.echo(f"   Official: ✓ Yes")
-
-                # Show any additional metadata
-                for key in ["license", "homepage", "repository"]:
-                    if info.get(key):
-                        typer.echo(f"   {key.capitalize()}: {info.get(key)}")
-
-            typer.echo()
-
+                    row["category"] = info.get('category')
+                deps = info.get("dependencies", [])
+                row["dependencies"] = ', '.join(deps) if deps else "None"
+
+            table_data.append(row)
+
+        # Display table
+        columns = ["name", "description", "version"]
+        if verbose:
+            columns.append("author")
+            if any("category" in row for row in table_data):
+                columns.append("category")
+            if any("dependencies" in row for row in table_data):
+                columns.append("dependencies")
+
+        title = f"Official Plugins Marketplace ({len(plugins_data)} available)"
         if category:
-            typer.echo(f"Showing plugins in category: {category}")
-        typer.echo("\nTip: Use --verbose to see more details")
+            title += f" - Category: {category}"
+
+        print_rich_table(
+            table_data,
+            title=title,
+            columns=columns,
+            json_output=False
+        )
+
+        if not verbose:
+            typer.echo("\nTip: Use --verbose to see more details")
 
     except Exception as e:
-        return format_error("MARKETPLACE_ERROR", str(e))
+        print_rich_error(
+            f"Failed to load marketplace: {e}",
+            code="MARKETPLACE_ERROR",
+            json_output=json_output or not is_human_mode()
+        )