remind-plugin-google-tasks 0.1.0__tar.gz

remind_plugin_google_tasks-0.1.0/.gitignore

@@ -0,0 +1,71 @@
+# Environment
+.env
+.env.*
+!.env.example
+
+# Databases
+*.db
+*.db-wal
+*.db-shm
+*.sqlite
+*.sqlite3
+*.pgsql
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Build artifacts
+dist/
+build/
+*.egg-info/
+
+# Logs
+*.log
+logs/
+
+# Node (future web app)
+node_modules/
+.next/
+out/

remind_plugin_google_tasks-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: remind-plugin-google-tasks
+Version: 0.1.0
+Summary: Google Tasks integration plugin for Remind CLI
+Author-email: Hamza Plojovic <hello@hamzaplojovic.com>
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: google-api-python-client>=2.100.0
+Requires-Dist: google-auth-httplib2>=0.2.0
+Requires-Dist: google-auth-oauthlib>=1.2.0
+Requires-Dist: remind-plugin-base>=0.1.0
+Requires-Dist: typer[all]>=0.9.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest-mock>=3.11.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# remind-plugin-google-tasks
+
+Sync reminders from Remind CLI with Google Tasks.
+
+When you create a reminder in Remind, it automatically appears in your Google Task list. Keep your tasks organized in one place.
+
+## Installation
+
+```bash
+# Install the plugin
+pip install remind-plugin-google-tasks
+
+# Or with uv
+uv pip install remind-plugin-google-tasks
+```
+
+## Setup
+
+1. Go to [Google Cloud Console](https://console.cloud.google.com) and create a new project
+2. Enable **Google Tasks API** for your project
+3. Create an **OAuth 2.0 credential** (Desktop app type)
+4. Download the `client_secrets.json` file
+5. Set the path:
+
+```bash
+export REMIND_GOOGLE_CLIENT_SECRETS_PATH=~/Downloads/client_secrets.json
+```
+
+6. Configure the plugin:
+
+```bash
+remind plugins add google-tasks
+```
+
+This will open your browser for OAuth authorization and let you select which Google Task list to sync with.
+
+## Usage
+
+Simply use Remind as normal:
+
+```bash
+remind add 'Buy groceries' --due 'tomorrow 5pm'
+```
+
+The reminder is instantly synced to your Google Task list.
+
+## Status
+
+Check plugin status anytime:
+
+```bash
+remind plugins
+remind doctor
+```
+
+## Uninstall
+
+```bash
+remind plugins remove google-tasks
+```
+
+## License
+
+MIT

remind_plugin_google_tasks-0.1.0/README.md

@@ -0,0 +1,64 @@
+# remind-plugin-google-tasks
+
+Sync reminders from Remind CLI with Google Tasks.
+
+When you create a reminder in Remind, it automatically appears in your Google Task list. Keep your tasks organized in one place.
+
+## Installation
+
+```bash
+# Install the plugin
+pip install remind-plugin-google-tasks
+
+# Or with uv
+uv pip install remind-plugin-google-tasks
+```
+
+## Setup
+
+1. Go to [Google Cloud Console](https://console.cloud.google.com) and create a new project
+2. Enable **Google Tasks API** for your project
+3. Create an **OAuth 2.0 credential** (Desktop app type)
+4. Download the `client_secrets.json` file
+5. Set the path:
+
+```bash
+export REMIND_GOOGLE_CLIENT_SECRETS_PATH=~/Downloads/client_secrets.json
+```
+
+6. Configure the plugin:
+
+```bash
+remind plugins add google-tasks
+```
+
+This will open your browser for OAuth authorization and let you select which Google Task list to sync with.
+
+## Usage
+
+Simply use Remind as normal:
+
+```bash
+remind add 'Buy groceries' --due 'tomorrow 5pm'
+```
+
+The reminder is instantly synced to your Google Task list.
+
+## Status
+
+Check plugin status anytime:
+
+```bash
+remind plugins
+remind doctor
+```
+
+## Uninstall
+
+```bash
+remind plugins remove google-tasks
+```
+
+## License
+
+MIT

remind_plugin_google_tasks-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "remind-plugin-google-tasks"
+version = "0.1.0"
+description = "Google Tasks integration plugin for Remind CLI"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Hamza Plojovic", email = "hello@hamzaplojovic.com" }]
+requires-python = ">=3.12"
+dependencies = [
+    "remind-plugin-base>=0.1.0",
+    "typer[all]>=0.9.0",
+    "google-auth-oauthlib>=1.2.0",
+    "google-auth-httplib2>=0.2.0",
+    "google-api-python-client>=2.100.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+    "pytest-mock>=3.11.0",
+]
+
+[project.entry-points."remind.plugins"]
+google-tasks = "remind_plugin_google_tasks:GoogleTasksPlugin"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/remind_plugin_google_tasks"]
+
+[tool.uv.sources]
+remind-plugin-base = { workspace = true }
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-v --tb=short"
+asyncio_mode = "auto"

remind_plugin_google_tasks-0.1.0/src/remind_plugin_google_tasks/__init__.py

@@ -0,0 +1,7 @@
+"""Google Tasks plugin for Remind."""
+
+from remind_plugin_google_tasks.plugin import GoogleTasksPlugin
+
+__version__ = "0.1.0"
+
+__all__ = ["GoogleTasksPlugin", "__version__"]

remind_plugin_google_tasks-0.1.0/src/remind_plugin_google_tasks/config.py

@@ -0,0 +1,17 @@
+"""Configuration models for Google Tasks plugin."""
+
+from pydantic import BaseModel
+
+
+class GoogleTasksConfig(BaseModel):
+    """Google Tasks plugin configuration."""
+
+    task_list_id: str
+    """The ID of the Google Task list to sync with."""
+
+    task_list_name: str
+    """The human-readable name of the task list (e.g., 'Remind')."""
+
+    class Config:
+        """Pydantic config."""
+        json_file = "config.json"

remind_plugin_google_tasks-0.1.0/src/remind_plugin_google_tasks/oauth.py

@@ -0,0 +1,165 @@
+"""Google OAuth 2.0 flow for Google Tasks."""
+
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from threading import Thread
+from typing import Optional
+from urllib.parse import parse_qs, urlparse
+
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+
+
+class LocalhostServer:
+    """Simple HTTP server to capture OAuth callback on localhost:8080."""
+
+    def __init__(self, port: int = 8080) -> None:
+        """Initialize server.
+
+        Args:
+            port: Port to listen on (default 8080).
+        """
+        self.port = port
+        self.auth_code: Optional[str] = None
+        self.server: Optional[HTTPServer] = None
+
+    def start(self) -> None:
+        """Start the server in a background thread."""
+        self.server = HTTPServer(("localhost", self.port), self._make_handler())
+
+        thread = Thread(target=self.server.handle_request, daemon=True)
+        thread.start()
+
+    def _make_handler(self):
+        """Create a request handler that captures the auth code."""
+        server = self
+
+        class Handler(BaseHTTPRequestHandler):
+            def do_GET(self):
+                """Handle GET request (OAuth callback)."""
+                parsed = urlparse(self.path)
+                params = parse_qs(parsed.query)
+
+                if "code" in params:
+                    server.auth_code = params["code"][0]
+                    self.send_response(200)
+                    self.send_header("Content-type", "text/html")
+                    self.end_headers()
+                    html = """
+                    <html>
+                    <head><title>Authorized</title></head>
+                    <body>
+                    <h1>Authorization Successful</h1>
+                    <p>You can close this window and return to your terminal.</p>
+                    </body>
+                    </html>
+                    """
+                    self.wfile.write(html.encode())
+                else:
+                    self.send_response(400)
+                    self.end_headers()
+
+            def log_message(self, _format, *_args):
+                """Suppress server logs."""
+                pass
+
+        return Handler
+
+    def stop(self) -> None:
+        """Stop the server."""
+        if self.server:
+            self.server.server_close()
+
+
+def get_google_credentials(
+    config_dir: Path, client_secrets_path: Optional[Path | str] = None
+) -> Credentials:
+    """Authenticate with Google and return credentials.
+
+    First tries to load existing credentials from config_dir.
+    If not found or expired, runs OAuth flow.
+
+    Args:
+        config_dir: Directory to store credentials (e.g., ~/.remind/plugins/google-tasks/).
+        client_secrets_path: Path to client_secrets.json from Google Cloud Console.
+                             If None, looks for REMIND_GOOGLE_CLIENT_SECRETS_PATH env var.
+
+    Returns:
+        Valid Google OAuth credentials.
+
+    Raises:
+        Exception: If OAuth flow fails or credentials not found.
+    """
+    import os
+
+    credentials_file = config_dir / "credentials.json"
+
+    # Try to load existing credentials
+    if credentials_file.exists():
+        creds = Credentials.from_authorized_user_file(str(credentials_file))
+        if creds.valid:
+            return creds
+        if creds.expired and creds.refresh_token:
+            creds.refresh(Request())
+            _save_credentials(creds, credentials_file)
+            return creds
+
+    # No valid credentials, run OAuth flow
+    if client_secrets_path is None:
+        env_path = os.environ.get("REMIND_GOOGLE_CLIENT_SECRETS_PATH")
+        if not env_path:
+            raise Exception(
+                "Google OAuth client secrets not found. "
+                "Set REMIND_GOOGLE_CLIENT_SECRETS_PATH or provide path to client_secrets.json from Google Cloud Console."
+            )
+        client_secrets_path = Path(env_path).expanduser()
+    else:
+        client_secrets_path = Path(client_secrets_path).expanduser()
+
+    if not client_secrets_path.exists():
+        raise Exception(f"Client secrets file not found: {client_secrets_path}")
+
+    # Run OAuth flow
+    scopes = ["https://www.googleapis.com/auth/tasks"]
+    flow = InstalledAppFlow.from_client_secrets_file(str(client_secrets_path), scopes)
+
+    # Run local server to capture callback
+    server = LocalhostServer()
+    server.start()
+
+    # Open browser for user to authorize
+    auth_url, _ = flow.authorization_url()
+    webbrowser.open(auth_url)
+
+    # Wait for callback (max 10 minutes)
+    import time
+
+    for _ in range(600):  # 10 minutes
+        if server.auth_code:
+            break
+        time.sleep(1)
+    else:
+        raise Exception("OAuth callback not received (timed out)")
+
+    server.stop()
+
+    # Exchange auth code for credentials
+    flow.fetch_token(code=server.auth_code)
+    creds = flow.credentials
+
+    # Save credentials
+    _save_credentials(creds, credentials_file)
+
+    return creds
+
+
+def _save_credentials(creds: Credentials, path: Path) -> None:
+    """Save credentials to a JSON file.
+
+    Args:
+        creds: Google OAuth credentials.
+        path: Path to save credentials to.
+    """
+    path.write_text(creds.to_json())

remind_plugin_google_tasks-0.1.0/src/remind_plugin_google_tasks/plugin.py

@@ -0,0 +1,191 @@
+"""Google Tasks plugin for Remind."""
+
+import json
+from pathlib import Path
+
+import typer
+from remind_plugin_base import BasePlugin, Reminder
+
+from remind_plugin_google_tasks.config import GoogleTasksConfig
+from remind_plugin_google_tasks.tasks_client import GoogleTasksClient
+
+
+class GoogleTasksPlugin(BasePlugin):
+    """Sync Remind reminders with Google Tasks."""
+
+    name = "google-tasks"
+    display_name = "Google Tasks"
+    version = "0.1.0"
+
+    def setup(self, config_dir: Path) -> None:
+        """Interactive setup wizard for Google Tasks.
+
+        Prompts user for Google OAuth credentials and task list selection.
+
+        Args:
+            config_dir: Path to ~/.remind/plugins/google-tasks/
+
+        Raises:
+            Exception: If setup fails.
+        """
+        typer.echo("\n[bold cyan]Google Tasks Setup[/bold cyan]\n")
+
+        try:
+            # Get OAuth credentials
+            typer.echo("1. Authenticating with Google...")
+            client = GoogleTasksClient(config_dir)
+
+            # List task lists and let user pick one
+            typer.echo("2. Fetching your Google Task lists...")
+            task_lists = client.list_task_lists()
+
+            if not task_lists:
+                typer.echo(
+                    "No task lists found. Creating a new one called 'Remind'...\n"
+                )
+                task_list_id = client.create_task_list("Remind")
+                task_list_name = "Remind"
+            else:
+                typer.echo("\nAvailable task lists:")
+                for i, tl in enumerate(task_lists, 1):
+                    typer.echo(f"  {i}. {tl['title']}")
+
+                choice = typer.prompt(
+                    "\nSelect a task list (number) or enter a name to create a new one",
+                    type=str,
+                )
+
+                if choice.isdigit() and 1 <= int(choice) <= len(task_lists):
+                    selected = task_lists[int(choice) - 1]
+                    task_list_id = selected["id"]
+                    task_list_name = selected["title"]
+                else:
+                    # Create new task list
+                    task_list_name = choice
+                    typer.echo(f"\nCreating new task list '{task_list_name}'...")
+                    task_list_id = client.create_task_list(task_list_name)
+
+            # Save config
+            config = GoogleTasksConfig(
+                task_list_id=task_list_id, task_list_name=task_list_name
+            )
+            config_file = config_dir / "config.json"
+            config_file.write_text(config.model_dump_json(indent=2))
+
+            # Create test task
+            typer.echo(f"\nCreating test task in '{task_list_name}'...")
+            client.insert_task(
+                task_list_id,
+                "✓ Remind CLI is connected to Google Tasks!",
+                "This task was created by the Remind CLI integration.",
+            )
+
+            typer.echo("\n[bold green]✓ Setup complete![/bold green]\n")
+
+        except Exception as e:
+            typer.echo(f"\n[bold red]✗ Setup failed: {e}[/bold red]\n")
+            raise
+
+    def teardown(self, config_dir: Path) -> None:
+        """Remove plugin credentials and configuration.
+
+        Args:
+            config_dir: Path to ~/.remind/plugins/google-tasks/
+
+        Raises:
+            Exception: If teardown fails.
+        """
+        try:
+            # Delete credentials file
+            credentials_file = config_dir / "credentials.json"
+            if credentials_file.exists():
+                credentials_file.unlink()
+
+            # Delete config file
+            config_file = config_dir / "config.json"
+            if config_file.exists():
+                config_file.unlink()
+
+            # Remove the plugin directory
+            if config_dir.exists():
+                config_dir.rmdir()
+
+        except Exception as e:
+            raise Exception(f"Failed to remove plugin configuration: {e}") from e
+
+    def is_configured(self, config_dir: Path) -> bool:
+        """Check if plugin is properly configured.
+
+        Args:
+            config_dir: Path to ~/.remind/plugins/google-tasks/
+
+        Returns:
+            True if both credentials and config exist.
+        """
+        credentials_file = config_dir / "credentials.json"
+        config_file = config_dir / "config.json"
+        return credentials_file.exists() and config_file.exists()
+
+    def status(self, config_dir: Path) -> str:
+        """Get status for doctor command.
+
+        Args:
+            config_dir: Path to ~/.remind/plugins/google-tasks/
+
+        Returns:
+            Status string.
+        """
+        if not self.is_configured(config_dir):
+            return "Not configured"
+
+        try:
+            config_file = config_dir / "config.json"
+            config_data = json.loads(config_file.read_text())
+            task_list_name = config_data.get("task_list_name", "Unknown")
+            return f"Authenticated, syncing to '{task_list_name}'"
+        except Exception:
+            return "Configured but error reading status"
+
+    def on_reminder_created(self, reminder: Reminder, config_dir: Path) -> None:
+        """Create a task in Google Tasks when a reminder is created.
+
+        Args:
+            reminder: The newly created reminder.
+            config_dir: Path to ~/.remind/plugins/google-tasks/
+        """
+        try:
+            config_file = config_dir / "config.json"
+            config_data = json.loads(config_file.read_text())
+            task_list_id = config_data["task_list_id"]
+
+            # Format task note with due date
+            notes = None
+            if reminder.due_date:
+                notes = f"Due: {reminder.due_date}"
+
+            client = GoogleTasksClient(config_dir)
+            client.insert_task(task_list_id, reminder.text, notes)
+
+        except Exception as e:
+            print(f"Error syncing reminder to Google Tasks: {e}")
+
+    def on_reminder_due(self, _reminder: Reminder, _config_dir: Path) -> None:
+        """Optionally send a notification when a reminder is due.
+
+        Args:
+            _reminder: The reminder that is due.
+            _config_dir: Path to ~/.remind/plugins/google-tasks/
+        """
+        # For now, just a no-op. Could integrate with Google Calendar or send emails.
+        pass
+
+    def on_reminder_done(self, _reminder: Reminder, _config_dir: Path) -> None:
+        """Mark task as done in Google Tasks when marked done in Remind.
+
+        Args:
+            _reminder: The reminder that was completed.
+            _config_dir: Path to ~/.remind/plugins/google-tasks/
+        """
+        # This would require tracking which Remind reminder ID maps to which Google Task ID.
+        # For now, this is a placeholder. Full implementation would store a mapping file.
+        pass

remind_plugin_google_tasks-0.1.0/src/remind_plugin_google_tasks/tasks_client.py

@@ -0,0 +1,97 @@
+"""Google Tasks API client."""
+
+from pathlib import Path
+from typing import Optional
+
+from googleapiclient.discovery import build
+
+from remind_plugin_google_tasks.oauth import get_google_credentials
+
+
+class GoogleTasksClient:
+    """Client for interacting with Google Tasks API."""
+
+    def __init__(self, config_dir: Path, client_secrets_path: Optional[Path] = None) -> None:
+        """Initialize client.
+
+        Args:
+            config_dir: Directory with credentials (e.g., ~/.remind/plugins/google-tasks/).
+            client_secrets_path: Path to client_secrets.json from Google Cloud Console.
+        """
+        self.config_dir = config_dir
+        self.client_secrets_path = client_secrets_path
+        self._service = None
+
+    def _get_service(self):
+        """Lazily initialize the Google Tasks service."""
+        if self._service is None:
+            creds = get_google_credentials(self.config_dir, self.client_secrets_path)
+            self._service = build("tasks", "v1", credentials=creds)
+        return self._service
+
+    def list_task_lists(self) -> list[dict]:
+        """Get all task lists.
+
+        Returns:
+            List of task list dicts with 'id', 'title' keys.
+        """
+        service = self._get_service()
+        results = service.tasklists().list(maxResults=10).execute()
+        return results.get("items", [])
+
+    def create_task_list(self, title: str) -> str:
+        """Create a new task list.
+
+        Args:
+            title: Name of the task list.
+
+        Returns:
+            ID of the created task list.
+        """
+        service = self._get_service()
+        task_list = {"title": title}
+        result = service.tasklists().insert(body=task_list).execute()
+        return result["id"]
+
+    def insert_task(self, task_list_id: str, title: str, notes: Optional[str] = None) -> str:
+        """Insert a new task.
+
+        Args:
+            task_list_id: ID of the task list.
+            title: Task title.
+            notes: Optional task notes/description.
+
+        Returns:
+            ID of the created task.
+        """
+        service = self._get_service()
+        task = {"title": title}
+        if notes:
+            task["notes"] = notes
+
+        result = service.tasks().insert(tasklist=task_list_id, body=task).execute()
+        return result["id"]
+
+    def update_task(
+        self, task_list_id: str, task_id: str, completed: bool = False
+    ) -> None:
+        """Update a task's status.
+
+        Args:
+            task_list_id: ID of the task list.
+            task_id: ID of the task to update.
+            completed: Whether the task is completed.
+        """
+        service = self._get_service()
+        task = {"id": task_id, "status": "completed" if completed else "needsAction"}
+        service.tasks().update(tasklist=task_list_id, task=task_id, body=task).execute()
+
+    def delete_task(self, task_list_id: str, task_id: str) -> None:
+        """Delete a task.
+
+        Args:
+            task_list_id: ID of the task list.
+            task_id: ID of the task to delete.
+        """
+        service = self._get_service()
+        service.tasks().delete(tasklist=task_list_id, task=task_id).execute()

remind_plugin_google_tasks-0.1.0/tests/test_plugin.py

@@ -0,0 +1,104 @@
+"""Tests for Google Tasks plugin."""
+
+import json
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from remind_plugin_google_tasks import GoogleTasksPlugin
+from remind_plugin_base import Reminder
+
+
+@pytest.fixture
+def plugin():
+    """Provide a plugin instance."""
+    return GoogleTasksPlugin()
+
+
+@pytest.fixture
+def config_dir(tmp_path):
+    """Provide a temporary config directory."""
+    return tmp_path
+
+
+def test_plugin_metadata():
+    """Test plugin metadata."""
+    plugin = GoogleTasksPlugin()
+    assert plugin.name == "google-tasks"
+    assert plugin.display_name == "Google Tasks"
+    assert plugin.version == "0.1.0"
+
+
+def test_is_configured_false_when_no_files(plugin, config_dir):
+    """Test is_configured returns False when credentials don't exist."""
+    assert not plugin.is_configured(config_dir)
+
+
+def test_is_configured_true_when_files_exist(plugin, config_dir):
+    """Test is_configured returns True when credentials and config exist."""
+    (config_dir / "credentials.json").write_text("{}")
+    (config_dir / "config.json").write_text("{}")
+    assert plugin.is_configured(config_dir)
+
+
+def test_status_not_configured(plugin, config_dir):
+    """Test status when not configured."""
+    status = plugin.status(config_dir)
+    assert status == "Not configured"
+
+
+def test_status_configured(plugin, config_dir):
+    """Test status when configured."""
+    (config_dir / "credentials.json").write_text("{}")
+    config = {"task_list_id": "test-list", "task_list_name": "My Tasks"}
+    (config_dir / "config.json").write_text(json.dumps(config))
+
+    status = plugin.status(config_dir)
+    assert "My Tasks" in status
+    assert "Authenticated" in status
+
+
+def test_teardown_removes_files(plugin, config_dir):
+    """Test teardown removes config files."""
+    (config_dir / "credentials.json").write_text("{}")
+    (config_dir / "config.json").write_text("{}")
+
+    plugin.teardown(config_dir)
+
+    assert not (config_dir / "credentials.json").exists()
+    assert not (config_dir / "config.json").exists()
+
+
+def test_on_reminder_created_creates_task(plugin, config_dir):
+    """Test on_reminder_created syncs to Google Tasks."""
+    config = {"task_list_id": "test-list", "task_list_name": "My Tasks"}
+    (config_dir / "config.json").write_text(json.dumps(config))
+    (config_dir / "credentials.json").write_text("{}")
+
+    reminder = Reminder(
+        id=1,
+        text="Buy groceries",
+        due_date="2025-02-18T17:00:00",
+        is_done=False,
+    )
+
+    with patch("remind_plugin_google_tasks.plugin.GoogleTasksClient") as mock_client:
+        mock_instance = MagicMock()
+        mock_client.return_value = mock_instance
+
+        plugin.on_reminder_created(reminder, config_dir)
+
+        mock_instance.insert_task.assert_called_once()
+        call_args = mock_instance.insert_task.call_args
+        assert call_args[0][0] == "test-list"
+        assert call_args[0][1] == "Buy groceries"
+        assert "2025-02-18T17:00:00" in call_args[0][2]
+
+
+def test_on_reminder_hooks_dont_error(plugin, config_dir):
+    """Test reminder hooks don't raise errors."""
+    reminder = Reminder(id=1, text="Test", is_done=False)
+
+    # Should not raise
+    plugin.on_reminder_due(reminder, config_dir)
+    plugin.on_reminder_done(reminder, config_dir)