taskdog-server 0.18.1__tar.gz

taskdog_server-0.18.1/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: taskdog-server
+Version: 0.18.1
+Summary: FastAPI server for Taskdog task management system
+Author: Kohei Wada
+License: MIT
+Project-URL: Homepage, https://github.com/Kohei-Wada/taskdog
+Project-URL: Repository, https://github.com/Kohei-Wada/taskdog
+Project-URL: Bug Tracker, https://github.com/Kohei-Wada/taskdog/issues
+Keywords: task,management,api,fastapi
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: taskdog-core==0.18.1
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: uvicorn[standard]>=0.32.0
+Requires-Dist: pydantic>=2.10.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.0.0; extra == "dev"
+Requires-Dist: httpx>=0.27.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.7.0; extra == "dev"
+
+# taskdog-server
+
+FastAPI server for Taskdog task management system.
+
+## Overview
+
+This package provides a REST API for all Taskdog functionality including:
+
+- Task CRUD operations
+- Task lifecycle management (start, complete, pause, cancel, reopen)
+- Task relationships (dependencies, tags)
+- Time tracking and logging
+- Schedule optimization
+- Statistics and analytics
+- WebSocket real-time updates
+
+## Installation
+
+```bash
+pip install taskdog-server
+```
+
+For development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Usage
+
+Start the server:
+
+```bash
+taskdog-server
+```
+
+With custom options:
+
+```bash
+taskdog-server --host 0.0.0.0 --port 3000
+```
+
+Development mode with auto-reload:
+
+```bash
+taskdog-server --reload
+```
+
+## API Documentation
+
+Once the server is running, visit:
+
+- Interactive API docs: http://localhost:8000/docs
+- Alternative docs: http://localhost:8000/redoc
+- Health check: http://localhost:8000/health
+
+For complete API reference, see [docs/API.md](../../docs/API.md).
+
+## Authentication
+
+Configure API key authentication in `~/.config/taskdog/server.toml`:
+
+```toml
+[auth]
+enabled = true
+
+[[auth.api_keys]]
+name = "my-client"
+key = "your-secret-key"
+```
+
+Clients authenticate via `X-Api-Key` header:
+
+```bash
+curl -H "X-Api-Key: your-secret-key" http://localhost:8000/api/v1/tasks/
+```
+
+See [Authentication Documentation](../../docs/API.md#authentication) for details.
+
+## WebSocket Real-time Updates
+
+Connect to `/ws` for real-time task notifications:
+
+```javascript
+const ws = new WebSocket('ws://localhost:8000/ws?token=your-api-key');
+
+ws.onmessage = (event) => {
+  const data = JSON.parse(event.data);
+  console.log('Event:', data.type);  // task_created, task_updated, etc.
+};
+```
+
+**Event types:**
+
+- `task_created` - New task created
+- `task_updated` - Task fields updated
+- `task_deleted` - Task deleted
+- `task_status_changed` - Task status changed
+- `schedule_optimized` - Schedule optimization completed
+
+**Note:** WebSocket uses an in-memory connection manager, so the server always runs as a single process.
+
+## Configuration
+
+Server configuration: `~/.config/taskdog/server.toml`
+
+```toml
+[auth]
+enabled = true
+
+[[auth.api_keys]]
+name = "my-client"
+key = "your-secret-key"
+
+[audit]
+enabled = false
+```
+
+Core configuration: `~/.config/taskdog/core.toml`
+
+```toml
+[region]
+country = "JP"
+```
+
+See [Configuration Guide](../../docs/CONFIGURATION.md) for all options.
+
+## Architecture
+
+The server uses:
+
+- **FastAPI**: Modern, fast web framework
+- **Pydantic**: Data validation with type hints
+- **uvicorn**: ASGI server
+- **taskdog-core**: Core business logic and infrastructure
+
+### API Routers
+
+- `tasks.py` - Task CRUD operations
+- `lifecycle.py` - Task status changes
+- `relationships.py` - Dependencies and tags
+- `analytics.py` - Statistics and reporting
+- `notes.py` - Markdown notes
+- `websocket.py` - Real-time updates
+
+### Dependency Injection
+
+Controllers are injected via FastAPI dependencies:
+
+```python
+CrudControllerDep = Annotated[TaskCrudController, Depends(get_crud_controller)]
+```
+
+## Related Packages
+
+- [taskdog-core](../taskdog-core/): Core business logic used by this package
+- [taskdog-ui](../taskdog-ui/): CLI and TUI interfaces connecting to this server
+- [taskdog-client](../taskdog-client/): HTTP client library for API access
+- [taskdog-mcp](../taskdog-mcp/): MCP server for Claude Desktop integration
+
+## Testing
+
+```bash
+pytest tests/
+```
+
+## Deployment
+
+### Systemd (Linux)
+
+```bash
+systemctl --user start taskdog-server
+systemctl --user enable taskdog-server
+```
+
+### Docker
+
+```bash
+docker pull ghcr.io/kohei-wada/taskdog-server:main
+docker run -d -p 8000:8000 -v taskdog-data:/data ghcr.io/kohei-wada/taskdog-server:main
+```
+
+See [contrib/README.md](../../contrib/README.md) for deployment details.
+
+## License
+
+MIT

taskdog_server-0.18.1/README.md

@@ -0,0 +1,187 @@
+# taskdog-server
+
+FastAPI server for Taskdog task management system.
+
+## Overview
+
+This package provides a REST API for all Taskdog functionality including:
+
+- Task CRUD operations
+- Task lifecycle management (start, complete, pause, cancel, reopen)
+- Task relationships (dependencies, tags)
+- Time tracking and logging
+- Schedule optimization
+- Statistics and analytics
+- WebSocket real-time updates
+
+## Installation
+
+```bash
+pip install taskdog-server
+```
+
+For development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Usage
+
+Start the server:
+
+```bash
+taskdog-server
+```
+
+With custom options:
+
+```bash
+taskdog-server --host 0.0.0.0 --port 3000
+```
+
+Development mode with auto-reload:
+
+```bash
+taskdog-server --reload
+```
+
+## API Documentation
+
+Once the server is running, visit:
+
+- Interactive API docs: http://localhost:8000/docs
+- Alternative docs: http://localhost:8000/redoc
+- Health check: http://localhost:8000/health
+
+For complete API reference, see [docs/API.md](../../docs/API.md).
+
+## Authentication
+
+Configure API key authentication in `~/.config/taskdog/server.toml`:
+
+```toml
+[auth]
+enabled = true
+
+[[auth.api_keys]]
+name = "my-client"
+key = "your-secret-key"
+```
+
+Clients authenticate via `X-Api-Key` header:
+
+```bash
+curl -H "X-Api-Key: your-secret-key" http://localhost:8000/api/v1/tasks/
+```
+
+See [Authentication Documentation](../../docs/API.md#authentication) for details.
+
+## WebSocket Real-time Updates
+
+Connect to `/ws` for real-time task notifications:
+
+```javascript
+const ws = new WebSocket('ws://localhost:8000/ws?token=your-api-key');
+
+ws.onmessage = (event) => {
+  const data = JSON.parse(event.data);
+  console.log('Event:', data.type);  // task_created, task_updated, etc.
+};
+```
+
+**Event types:**
+
+- `task_created` - New task created
+- `task_updated` - Task fields updated
+- `task_deleted` - Task deleted
+- `task_status_changed` - Task status changed
+- `schedule_optimized` - Schedule optimization completed
+
+**Note:** WebSocket uses an in-memory connection manager, so the server always runs as a single process.
+
+## Configuration
+
+Server configuration: `~/.config/taskdog/server.toml`
+
+```toml
+[auth]
+enabled = true
+
+[[auth.api_keys]]
+name = "my-client"
+key = "your-secret-key"
+
+[audit]
+enabled = false
+```
+
+Core configuration: `~/.config/taskdog/core.toml`
+
+```toml
+[region]
+country = "JP"
+```
+
+See [Configuration Guide](../../docs/CONFIGURATION.md) for all options.
+
+## Architecture
+
+The server uses:
+
+- **FastAPI**: Modern, fast web framework
+- **Pydantic**: Data validation with type hints
+- **uvicorn**: ASGI server
+- **taskdog-core**: Core business logic and infrastructure
+
+### API Routers
+
+- `tasks.py` - Task CRUD operations
+- `lifecycle.py` - Task status changes
+- `relationships.py` - Dependencies and tags
+- `analytics.py` - Statistics and reporting
+- `notes.py` - Markdown notes
+- `websocket.py` - Real-time updates
+
+### Dependency Injection
+
+Controllers are injected via FastAPI dependencies:
+
+```python
+CrudControllerDep = Annotated[TaskCrudController, Depends(get_crud_controller)]
+```
+
+## Related Packages
+
+- [taskdog-core](../taskdog-core/): Core business logic used by this package
+- [taskdog-ui](../taskdog-ui/): CLI and TUI interfaces connecting to this server
+- [taskdog-client](../taskdog-client/): HTTP client library for API access
+- [taskdog-mcp](../taskdog-mcp/): MCP server for Claude Desktop integration
+
+## Testing
+
+```bash
+pytest tests/
+```
+
+## Deployment
+
+### Systemd (Linux)
+
+```bash
+systemctl --user start taskdog-server
+systemctl --user enable taskdog-server
+```
+
+### Docker
+
+```bash
+docker pull ghcr.io/kohei-wada/taskdog-server:main
+docker run -d -p 8000:8000 -v taskdog-data:/data ghcr.io/kohei-wada/taskdog-server:main
+```
+
+See [contrib/README.md](../../contrib/README.md) for deployment details.
+
+## License
+
+MIT

taskdog_server-0.18.1/pyproject.toml

@@ -0,0 +1,79 @@
+[project]
+name = "taskdog-server"
+version = "0.18.1"
+description = "FastAPI server for Taskdog task management system"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [
+    { name = "Kohei Wada" }
+]
+license = { text = "MIT" }
+keywords = ["task", "management", "api", "fastapi"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+dependencies = [
+    "taskdog-core==0.18.1",
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.32.0",
+    "pydantic>=2.10.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "pytest-asyncio>=1.0.0",
+    "httpx>=0.27.0",  # For testing API endpoints
+    "mypy>=1.0.0",
+    "ruff>=0.7.0",
+]
+
+[project.scripts]
+taskdog-server = "taskdog_server.main:main"
+
+[project.urls]
+Homepage = "https://github.com/Kohei-Wada/taskdog"
+Repository = "https://github.com/Kohei-Wada/taskdog"
+"Bug Tracker" = "https://github.com/Kohei-Wada/taskdog/issues"
+
+[build-system]
+requires = ["setuptools>=68.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = [
+    "taskdog_server",
+    "taskdog_server.api",
+    "taskdog_server.api.models",
+    "taskdog_server.api.routers",
+    "taskdog_server.config",
+    "taskdog_server.websocket",
+    "taskdog_server.infrastructure",
+    "taskdog_server.infrastructure.logging",
+]
+package-dir = { "" = "src" }
+
+[tool.setuptools.package-data]
+taskdog_server = ["py.typed"]
+
+[tool.mypy]
+python_version = "3.13"
+strict = true
+# Disable unused-ignore warnings (environment-dependent)
+warn_unused_ignores = false
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+asyncio_mode = "auto"
+filterwarnings = [
+    "ignore::ResourceWarning:holidays.*",
+]

taskdog_server-0.18.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

taskdog_server-0.18.1/src/taskdog_server/__init__.py

@@ -0,0 +1,11 @@
+"""Taskdog API Server.
+
+FastAPI-based REST API server for task management.
+"""
+
+from importlib.metadata import version
+
+try:
+    __version__ = version("taskdog-server")
+except Exception:
+    __version__ = "unknown"

taskdog_server-0.18.1/src/taskdog_server/api/__init__.py

@@ -0,0 +1,5 @@
+"""FastAPI presentation layer for Taskdog."""
+
+from taskdog_server.api.app import app, create_app
+
+__all__ = ["app", "create_app"]

taskdog_server-0.18.1/src/taskdog_server/api/app.py

@@ -0,0 +1,100 @@
+"""FastAPI application factory and configuration."""
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from taskdog_core.shared.config_manager import ConfigManager
+from taskdog_server import __version__
+from taskdog_server.api.dependencies import initialize_api_context
+from taskdog_server.api.middleware import LoggingMiddleware
+from taskdog_server.api.routers import (
+    analytics_router,
+    audit_router,
+    bulk_router,
+    lifecycle_router,
+    notes_router,
+    relationships_router,
+    tags_router,
+    tasks_router,
+    websocket_router,
+)
+from taskdog_server.config.server_config_manager import ServerConfigManager
+from taskdog_server.infrastructure.logging.config import configure_logging
+from taskdog_server.websocket.connection_manager import ConnectionManager
+
+
+def create_app() -> FastAPI:
+    """Create and configure FastAPI application.
+
+    Returns:
+        FastAPI: Configured FastAPI application instance
+    """
+    # Load configuration once for the entire app
+    config = ConfigManager.load()
+    server_config = ServerConfigManager.load()
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+        """FastAPI lifespan context manager.
+
+        Initializes logging, API context, and connection manager on startup.
+        Stores all state in app.state for proper scoping.
+        """
+        # Startup: Configure logging first
+        configure_logging()
+
+        # Initialize API context and store in app.state
+        api_context = initialize_api_context(config)
+        app.state.api_context = api_context
+
+        # Store server config in app.state (for authentication)
+        app.state.server_config = server_config
+
+        # Initialize ConnectionManager in app.state (for WebSocket)
+        app.state.connection_manager = ConnectionManager()
+
+        yield
+
+        # Shutdown: Dispose shared database engine
+        api_context.close()
+
+    app = FastAPI(
+        title="Taskdog API",
+        description="Task management API with scheduling, dependencies, and analytics",
+        version=__version__,
+        lifespan=lifespan,
+    )
+
+    # Add logging middleware (should be first to log all requests)
+    app.add_middleware(LoggingMiddleware)
+
+    # Register routers
+    app.include_router(bulk_router, prefix="/api/v1/tasks", tags=["bulk"])
+    app.include_router(tasks_router, prefix="/api/v1/tasks", tags=["tasks"])
+    app.include_router(lifecycle_router, prefix="/api/v1/tasks", tags=["lifecycle"])
+    app.include_router(
+        relationships_router, prefix="/api/v1/tasks", tags=["relationships"]
+    )
+    app.include_router(notes_router, prefix="/api/v1/tasks", tags=["notes"])
+    app.include_router(analytics_router, prefix="/api/v1", tags=["analytics"])
+    app.include_router(tags_router, prefix="/api/v1/tags", tags=["tags"])
+    app.include_router(audit_router, prefix="/api/v1/audit-logs", tags=["audit"])
+    app.include_router(websocket_router, tags=["websocket"])
+
+    @app.get("/")
+    async def root() -> dict[str, str]:
+        """Root endpoint."""
+        return {"message": "Taskdog API", "version": __version__}
+
+    @app.get("/health")
+    async def health() -> dict[str, str]:
+        """Health check endpoint."""
+        return {"status": "ok"}
+
+    return app
+
+
+# Create app instance
+app = create_app()

taskdog_server-0.18.1/src/taskdog_server/api/context.py

@@ -0,0 +1,60 @@
+"""API context for dependency injection."""
+
+from dataclasses import dataclass, field
+
+from sqlalchemy.engine import Engine
+
+from taskdog_core.controllers.audit_log_controller import AuditLogController
+from taskdog_core.controllers.bulk_task_controller import BulkTaskController
+from taskdog_core.controllers.query_controller import QueryController
+from taskdog_core.controllers.task_analytics_controller import TaskAnalyticsController
+from taskdog_core.controllers.task_crud_controller import TaskCrudController
+from taskdog_core.controllers.task_lifecycle_controller import TaskLifecycleController
+from taskdog_core.controllers.task_relationship_controller import (
+    TaskRelationshipController,
+)
+from taskdog_core.domain.repositories.notes_repository import NotesRepository
+from taskdog_core.domain.repositories.task_repository import TaskRepository
+from taskdog_core.domain.services.holiday_checker import IHolidayChecker
+from taskdog_core.domain.services.time_provider import ITimeProvider
+from taskdog_core.shared.config_manager import Config
+
+
+@dataclass
+class ApiContext:
+    """Context object for API endpoints containing shared dependencies.
+
+    Attributes:
+        repository: Task repository for data access
+        config: Application configuration
+        notes_repository: Notes repository for notes file operations
+        query_controller: Controller for task read operations
+        lifecycle_controller: Controller for task lifecycle operations (start, complete, etc.)
+        relationship_controller: Controller for task relationships (dependencies, tags, hours)
+        analytics_controller: Controller for analytics operations (statistics, optimization)
+        crud_controller: Controller for CRUD operations (create, update, archive, etc.)
+        holiday_checker: Holiday checker for workday validation (optional)
+        time_provider: Time provider for current time (optional, defaults to SystemTimeProvider)
+        audit_log_controller: Controller for audit log operations
+        engine: Shared SQLAlchemy engine (owned by this context)
+    """
+
+    repository: TaskRepository
+    config: Config
+    notes_repository: NotesRepository
+    query_controller: QueryController
+    lifecycle_controller: TaskLifecycleController
+    relationship_controller: TaskRelationshipController
+    analytics_controller: TaskAnalyticsController
+    crud_controller: TaskCrudController
+    holiday_checker: IHolidayChecker | None
+    time_provider: ITimeProvider
+    audit_log_controller: AuditLogController
+    bulk_controller: BulkTaskController | None = None
+    engine: Engine | None = field(default=None, repr=False)
+
+    def close(self) -> None:
+        """Dispose the shared engine to release database connections."""
+        if self.engine is not None:
+            self.engine.dispose()
+            self.engine = None