taskdog-core 0.18.1__tar.gz

taskdog_core-0.18.1/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: taskdog-core
+Version: 0.18.1
+Summary: Core business logic and infrastructure for Taskdog
+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,scheduling
+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: alembic>=1.13.0
+Requires-Dist: holidays>=0.60.0
+Requires-Dist: sqlalchemy>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.7.0; extra == "dev"
+
+# taskdog-core
+
+Core business logic and infrastructure for Taskdog task management system.
+
+## Overview
+
+This package contains the core components shared by both the Taskdog server and UI:
+
+- **Domain Layer**: Business entities, domain services, and interfaces
+- **Application Layer**: Use cases, queries, DTOs, and business logic orchestration
+- **Infrastructure Layer**: Persistence implementations, external service integrations
+- **Controllers**: Business logic orchestrators used by presentation layers
+
+## Installation
+
+```bash
+pip install taskdog-core
+```
+
+For development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Architecture
+
+Follows Clean Architecture principles:
+
+```text
+Domain (entities, services, repositories)
+  ↑
+Application (use cases, queries, DTOs)
+  ↑
+Infrastructure (SQLite, file storage)
+  ↑
+Controllers (orchestration layer)
+```
+
+### Key Components
+
+**Domain Layer** (`taskdog_core/domain/`):
+
+- `Task` - Core entity with status, priority, deadlines, dependencies
+- `TaskStatus` - PENDING, IN_PROGRESS, COMPLETED, CANCELED
+- `TimeTracker` - Records actual_start/actual_end timestamps
+- `TaskNotFoundException`, `TaskValidationError` - Domain exceptions
+
+**Application Layer** (`taskdog_core/application/`):
+
+- **Use Cases**: CreateTaskUseCase, StartTaskUseCase, OptimizeScheduleUseCase, etc.
+- **Validators**: TaskFieldValidatorRegistry with Status and Dependency validators
+- **Services**: WorkloadAllocator, OptimizationSummaryBuilder, TaskQueryService
+- **Optimization**: 9 scheduling strategies (greedy, balanced, backward, priority_first, earliest_deadline, round_robin, dependency_aware, genetic, monte_carlo)
+
+**Infrastructure Layer** (`taskdog_core/infrastructure/`):
+
+- `SqliteTaskRepository` - SQLite persistence with transactional writes
+- `SqliteNotesRepository` - Database-based notes storage
+- `ConfigManager` - TOML configuration loading
+
+**Controllers** (`taskdog_core/controllers/`):
+
+- `TaskCrudController` - Create, update, delete operations
+- `TaskLifecycleController` - Start, complete, pause, cancel, reopen
+- `TaskRelationshipController` - Dependencies and tags
+- `TaskAnalyticsController` - Statistics and optimization
+- `QueryController` - Read-only operations
+
+## Usage Example
+
+```python
+from taskdog_core.domain.entities.task import Task, TaskStatus
+from taskdog_core.infrastructure.persistence.database.sqlite_task_repository import SqliteTaskRepository
+from taskdog_core.controllers.task_crud_controller import TaskCrudController
+from taskdog_core.infrastructure.config.config_manager import ConfigManager
+from taskdog_core.shared.utils.logger import StandardLogger
+
+# Setup
+repository = SqliteTaskRepository("sqlite:///tasks.db")
+config = ConfigManager()
+logger = StandardLogger("example")
+
+# Create controller
+crud_controller = TaskCrudController(repository, config, logger)
+
+# Create a task
+from taskdog_core.application.dto.task_request import CreateTaskRequest
+request = CreateTaskRequest(name="My Task", priority=100)
+task = crud_controller.create_task(request)
+```
+
+## Dependencies
+
+- `holidays`: Holiday checking for scheduling
+- `python-dateutil`: Date/time utilities
+- `sqlalchemy`: Database ORM
+
+## Related Packages
+
+- [taskdog-server](../taskdog-server/): FastAPI REST API server using this package
+- [taskdog-ui](../taskdog-ui/): CLI and TUI interfaces using this package
+- [taskdog-client](../taskdog-client/): HTTP client library for API access
+
+For detailed architecture documentation, see [CLAUDE.md](../../CLAUDE.md).
+
+## Testing
+
+```bash
+pytest tests/
+```
+
+## License
+
+MIT

taskdog_core-0.18.1/README.md

@@ -0,0 +1,115 @@
+# taskdog-core
+
+Core business logic and infrastructure for Taskdog task management system.
+
+## Overview
+
+This package contains the core components shared by both the Taskdog server and UI:
+
+- **Domain Layer**: Business entities, domain services, and interfaces
+- **Application Layer**: Use cases, queries, DTOs, and business logic orchestration
+- **Infrastructure Layer**: Persistence implementations, external service integrations
+- **Controllers**: Business logic orchestrators used by presentation layers
+
+## Installation
+
+```bash
+pip install taskdog-core
+```
+
+For development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Architecture
+
+Follows Clean Architecture principles:
+
+```text
+Domain (entities, services, repositories)
+  ↑
+Application (use cases, queries, DTOs)
+  ↑
+Infrastructure (SQLite, file storage)
+  ↑
+Controllers (orchestration layer)
+```
+
+### Key Components
+
+**Domain Layer** (`taskdog_core/domain/`):
+
+- `Task` - Core entity with status, priority, deadlines, dependencies
+- `TaskStatus` - PENDING, IN_PROGRESS, COMPLETED, CANCELED
+- `TimeTracker` - Records actual_start/actual_end timestamps
+- `TaskNotFoundException`, `TaskValidationError` - Domain exceptions
+
+**Application Layer** (`taskdog_core/application/`):
+
+- **Use Cases**: CreateTaskUseCase, StartTaskUseCase, OptimizeScheduleUseCase, etc.
+- **Validators**: TaskFieldValidatorRegistry with Status and Dependency validators
+- **Services**: WorkloadAllocator, OptimizationSummaryBuilder, TaskQueryService
+- **Optimization**: 9 scheduling strategies (greedy, balanced, backward, priority_first, earliest_deadline, round_robin, dependency_aware, genetic, monte_carlo)
+
+**Infrastructure Layer** (`taskdog_core/infrastructure/`):
+
+- `SqliteTaskRepository` - SQLite persistence with transactional writes
+- `SqliteNotesRepository` - Database-based notes storage
+- `ConfigManager` - TOML configuration loading
+
+**Controllers** (`taskdog_core/controllers/`):
+
+- `TaskCrudController` - Create, update, delete operations
+- `TaskLifecycleController` - Start, complete, pause, cancel, reopen
+- `TaskRelationshipController` - Dependencies and tags
+- `TaskAnalyticsController` - Statistics and optimization
+- `QueryController` - Read-only operations
+
+## Usage Example
+
+```python
+from taskdog_core.domain.entities.task import Task, TaskStatus
+from taskdog_core.infrastructure.persistence.database.sqlite_task_repository import SqliteTaskRepository
+from taskdog_core.controllers.task_crud_controller import TaskCrudController
+from taskdog_core.infrastructure.config.config_manager import ConfigManager
+from taskdog_core.shared.utils.logger import StandardLogger
+
+# Setup
+repository = SqliteTaskRepository("sqlite:///tasks.db")
+config = ConfigManager()
+logger = StandardLogger("example")
+
+# Create controller
+crud_controller = TaskCrudController(repository, config, logger)
+
+# Create a task
+from taskdog_core.application.dto.task_request import CreateTaskRequest
+request = CreateTaskRequest(name="My Task", priority=100)
+task = crud_controller.create_task(request)
+```
+
+## Dependencies
+
+- `holidays`: Holiday checking for scheduling
+- `python-dateutil`: Date/time utilities
+- `sqlalchemy`: Database ORM
+
+## Related Packages
+
+- [taskdog-server](../taskdog-server/): FastAPI REST API server using this package
+- [taskdog-ui](../taskdog-ui/): CLI and TUI interfaces using this package
+- [taskdog-client](../taskdog-client/): HTTP client library for API access
+
+For detailed architecture documentation, see [CLAUDE.md](../../CLAUDE.md).
+
+## Testing
+
+```bash
+pytest tests/
+```
+
+## License
+
+MIT

taskdog_core-0.18.1/pyproject.toml

@@ -0,0 +1,112 @@
+[project]
+name = "taskdog-core"
+version = "0.18.1"
+description = "Core business logic and infrastructure for Taskdog"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [
+    { name = "Kohei Wada" }
+]
+license = { text = "MIT" }
+keywords = ["task", "management", "scheduling"]
+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 = [
+    "alembic>=1.13.0",
+    "holidays>=0.60.0",
+    "sqlalchemy>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "mypy>=1.0.0",
+    "ruff>=0.7.0",
+]
+
+[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_core",
+    "taskdog_core.domain",
+    "taskdog_core.domain.entities",
+    "taskdog_core.domain.services",
+    "taskdog_core.domain.repositories",
+    "taskdog_core.domain.exceptions",
+    "taskdog_core.application",
+    "taskdog_core.application.dto",
+    "taskdog_core.application.use_cases",
+    "taskdog_core.application.services",
+    "taskdog_core.application.services.optimization",
+    "taskdog_core.application.queries",
+    "taskdog_core.application.queries.filters",
+    "taskdog_core.application.queries.workload",
+    "taskdog_core.application.queries.workload._strategies",
+    "taskdog_core.application.sorters",
+    "taskdog_core.application.validators",
+    "taskdog_core.application.constants",
+    "taskdog_core.application.utils",
+    "taskdog_core.infrastructure",
+    "taskdog_core.infrastructure.persistence",
+    "taskdog_core.infrastructure.persistence.database",
+    "taskdog_core.infrastructure.persistence.database.models",
+    "taskdog_core.infrastructure.persistence.database.query_builders",
+    "taskdog_core.infrastructure.persistence.database.mutation_builders",
+    "taskdog_core.infrastructure.persistence.mappers",
+    "taskdog_core.controllers",
+    "taskdog_core.shared",
+    "taskdog_core.shared.constants",
+    "taskdog_core.shared.utils",
+    "taskdog_core.infrastructure.persistence.database.migrations",
+    "taskdog_core.infrastructure.persistence.database.migrations.versions",
+]
+package-dir = { "" = "src" }
+
+[tool.setuptools.package-data]
+taskdog_core = ["py.typed"]
+"taskdog_core.infrastructure.persistence.database.migrations" = ["*.mako"]
+
+[tool.mypy]
+python_version = "3.13"
+strict = true
+# Disable unused-ignore warnings (SQLAlchemy attr-defined errors are environment-dependent)
+warn_unused_ignores = false
+
+[[tool.mypy.overrides]]
+module = "alembic.*"
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+
+[tool.coverage.run]
+omit = [
+    "*/migrations/*",
+    "*/migrations/versions/*",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "raise NotImplementedError",
+    "@abstractmethod",
+]

taskdog_core-0.18.1/setup.cfg

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

taskdog_core-0.18.1/src/taskdog_core/application/__init__.py

@@ -0,0 +1 @@
+"""Application layer - Use cases and queries."""

taskdog_core-0.18.1/src/taskdog_core/application/constants/__init__.py

@@ -0,0 +1,27 @@
+"""Application layer constants."""
+
+from taskdog_core.application.constants.optimization import (
+    DEADLINE_PENALTY_MULTIPLIER,
+    GENETIC_CROSSOVER_RATE,
+    GENETIC_EARLY_TERMINATION_GENERATIONS,
+    GENETIC_GENERATIONS,
+    GENETIC_MUTATION_RATE,
+    GENETIC_POPULATION_SIZE,
+    GENETIC_TOURNAMENT_SIZE,
+    MONTE_CARLO_NUM_SIMULATIONS,
+    ROUND_ROBIN_MAX_ITERATIONS,
+    SCHEDULING_EPSILON,
+)
+
+__all__ = [
+    "DEADLINE_PENALTY_MULTIPLIER",
+    "GENETIC_CROSSOVER_RATE",
+    "GENETIC_EARLY_TERMINATION_GENERATIONS",
+    "GENETIC_GENERATIONS",
+    "GENETIC_MUTATION_RATE",
+    "GENETIC_POPULATION_SIZE",
+    "GENETIC_TOURNAMENT_SIZE",
+    "MONTE_CARLO_NUM_SIMULATIONS",
+    "ROUND_ROBIN_MAX_ITERATIONS",
+    "SCHEDULING_EPSILON",
+]

taskdog_core-0.18.1/src/taskdog_core/application/constants/optimization.py

@@ -0,0 +1,29 @@
+"""Optimization algorithm constants and default parameters."""
+
+# Genetic Algorithm Parameters
+GENETIC_POPULATION_SIZE = 20  # Number of individuals in population
+GENETIC_GENERATIONS = (
+    30  # Number of evolution generations (reduced from 50 for performance)
+)
+GENETIC_CROSSOVER_RATE = 0.8  # Probability of crossover between parents
+GENETIC_MUTATION_RATE = 0.2  # Probability of mutation in offspring
+GENETIC_TOURNAMENT_SIZE = 3  # Number of individuals in tournament selection
+GENETIC_EARLY_TERMINATION_GENERATIONS = (
+    10  # Stop if no improvement for this many generations
+)
+
+# Monte Carlo Parameters
+MONTE_CARLO_NUM_SIMULATIONS = (
+    50  # Number of random simulations to run (reduced from 100 for performance)
+)
+
+# Round Robin Parameters
+ROUND_ROBIN_MAX_ITERATIONS = 10000  # Safety limit to prevent infinite loops
+
+# Penalty Multipliers (shared across multiple algorithms)
+DEADLINE_PENALTY_MULTIPLIER = (
+    100  # Penalty for missing deadlines in fitness calculations
+)
+
+# Scheduling Precision
+SCHEDULING_EPSILON = 0.001  # Minimum hours threshold for scheduling calculations

taskdog_core-0.18.1/src/taskdog_core/application/dto/__init__.py

@@ -0,0 +1,40 @@
+"""Data Transfer Objects."""
+
+from taskdog_core.application.dto.base import SingleTaskInput
+from taskdog_core.application.dto.gantt_output import GanttDateRange, GanttOutput
+from taskdog_core.application.dto.query_inputs import (
+    GetGanttDataInput,
+    ListTasksInput,
+    TimeRange,
+)
+from taskdog_core.application.dto.statistics_output import (
+    CalculateStatisticsInput,
+    DeadlineComplianceStatistics,
+    EstimationAccuracyStatistics,
+    PriorityDistributionStatistics,
+    StatisticsOutput,
+    TaskStatistics,
+    TimeStatistics,
+    TrendStatistics,
+)
+from taskdog_core.application.dto.status_change_output import StatusChangeOutput
+from taskdog_core.application.dto.task_detail_output import TaskDetailOutput
+
+__all__ = [
+    "CalculateStatisticsInput",
+    "DeadlineComplianceStatistics",
+    "EstimationAccuracyStatistics",
+    "GanttDateRange",
+    "GanttOutput",
+    "GetGanttDataInput",
+    "ListTasksInput",
+    "PriorityDistributionStatistics",
+    "SingleTaskInput",
+    "StatisticsOutput",
+    "StatusChangeOutput",
+    "TaskDetailOutput",
+    "TaskStatistics",
+    "TimeRange",
+    "TimeStatistics",
+    "TrendStatistics",
+]

taskdog_core-0.18.1/src/taskdog_core/application/dto/audit_log_dto.py

@@ -0,0 +1,139 @@
+"""DTOs for audit logging operations.
+
+This module defines data transfer objects for audit log operations,
+including the audit event structure and query parameters.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+
+@dataclass(frozen=True)
+class AuditEvent:
+    """Represents a single audit log event.
+
+    This DTO is used to capture audit information when API operations
+    are performed. It tracks who did what, when, and what changed.
+    """
+
+    timestamp: datetime
+    """When the operation occurred."""
+
+    operation: str
+    """The type of operation (e.g., 'create_task', 'complete_task')."""
+
+    resource_type: str
+    """The type of resource (e.g., 'task', 'schedule')."""
+
+    success: bool
+    """Whether the operation succeeded."""
+
+    client_name: str | None = None
+    """The authenticated client name (e.g., 'claude-code')."""
+
+    resource_id: int | None = None
+    """The ID of the affected resource (task ID, etc.)."""
+
+    resource_name: str | None = None
+    """The name of the affected resource (task name, etc.)."""
+
+    old_values: dict[str, Any] | None = None
+    """Values before the change (for update operations)."""
+
+    new_values: dict[str, Any] | None = None
+    """Values after the change."""
+
+    error_message: str | None = None
+    """Error message if the operation failed."""
+
+
+@dataclass(frozen=True)
+class AuditQuery:
+    """Query parameters for filtering audit logs.
+
+    All fields are optional. If not specified, no filtering is applied
+    for that field.
+    """
+
+    client_name: str | None = None
+    """Filter by client name."""
+
+    operation: str | None = None
+    """Filter by operation type."""
+
+    resource_type: str | None = None
+    """Filter by resource type."""
+
+    resource_id: int | None = None
+    """Filter by resource ID (task ID)."""
+
+    success: bool | None = None
+    """Filter by success status."""
+
+    start_date: datetime | None = None
+    """Filter logs from this date onwards."""
+
+    end_date: datetime | None = None
+    """Filter logs up to this date."""
+
+    limit: int = 100
+    """Maximum number of logs to return."""
+
+    offset: int = 0
+    """Number of logs to skip (for pagination)."""
+
+
+@dataclass(frozen=True)
+class AuditLogOutput:
+    """Output DTO for a single audit log entry."""
+
+    id: int
+    """Unique identifier for the audit log entry."""
+
+    timestamp: datetime
+    """When the operation occurred."""
+
+    client_name: str | None
+    """The authenticated client name."""
+
+    operation: str
+    """The type of operation."""
+
+    resource_type: str
+    """The type of resource."""
+
+    resource_id: int | None
+    """The ID of the affected resource."""
+
+    resource_name: str | None
+    """The name of the affected resource."""
+
+    old_values: dict[str, Any] | None
+    """Values before the change."""
+
+    new_values: dict[str, Any] | None
+    """Values after the change."""
+
+    success: bool
+    """Whether the operation succeeded."""
+
+    error_message: str | None
+    """Error message if the operation failed."""
+
+
+@dataclass(frozen=True)
+class AuditLogListOutput:
+    """Output DTO for audit log list with pagination info."""
+
+    logs: list[AuditLogOutput] = field(default_factory=list)
+    """List of audit log entries."""
+
+    total_count: int = 0
+    """Total number of logs matching the query (for pagination)."""
+
+    limit: int = 100
+    """Maximum number of logs returned."""
+
+    offset: int = 0
+    """Number of logs skipped."""

taskdog_core-0.18.1/src/taskdog_core/application/dto/base.py

@@ -0,0 +1,17 @@
+"""Base DTO classes for task operations."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class SingleTaskInput:
+    """Request data for single-task operations.
+
+    This base class is used for operations that only require a task ID,
+    such as starting, completing, pausing, removing, or archiving a task.
+
+    Attributes:
+        task_id: ID of the task to operate on
+    """
+
+    task_id: int

taskdog_core-0.18.1/src/taskdog_core/application/dto/bulk_operation_output.py

@@ -0,0 +1,24 @@
+"""Output DTOs for bulk task operations."""
+
+from dataclasses import dataclass
+
+from taskdog_core.application.dto.task_operation_output import TaskOperationOutput
+
+
+@dataclass
+class BulkTaskResultOutput:
+    """Result for a single task in a bulk operation."""
+
+    task_id: int
+    success: bool
+    task: TaskOperationOutput | None
+    error: str | None
+    old_status: str | None = None
+    task_name: str | None = None
+
+
+@dataclass
+class BulkOperationOutput:
+    """Output DTO for bulk task operations."""
+
+    results: list[BulkTaskResultOutput]

taskdog_core-0.18.1/src/taskdog_core/application/dto/create_task_input.py

@@ -0,0 +1,29 @@
+"""DTO for creating a task."""
+
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class CreateTaskInput:
+    """Request data for creating a task.
+
+    Attributes:
+        name: Task name
+        priority: Task priority (higher value = higher priority), or None if not set
+        planned_start: Planned start datetime (optional)
+        planned_end: Planned end datetime (optional)
+        deadline: Deadline datetime (optional)
+        estimated_duration: Estimated duration in hours (optional)
+        is_fixed: Whether task schedule is fixed and shouldn't be changed by optimizer (optional)
+        tags: List of tags for categorization and filtering (optional)
+    """
+
+    name: str
+    priority: int | None = None
+    planned_start: datetime | None = None
+    planned_end: datetime | None = None
+    deadline: datetime | None = None
+    estimated_duration: float | None = None
+    is_fixed: bool = False
+    tags: list[str] | None = None