taskdog-ui 0.18.1__py3-none-any.whl

taskdog/__init__.py

@@ -0,0 +1,8 @@
+"""taskdog - CLI task management tool"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("taskdog-ui")
+except PackageNotFoundError:
+    __version__ = "unknown"

taskdog/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI interface."""

taskdog/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands."""

taskdog/cli/commands/add.py

@@ -0,0 +1,148 @@
+"""Add command - Add a new task."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import click
+
+from taskdog.cli.error_handler import handle_task_errors
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+    from taskdog.cli.context import CliContext
+from taskdog_core.domain.exceptions.task_exceptions import TaskValidationError
+
+
+@click.command(name="add", help="Add a new task.")
+@click.argument("name", type=str)
+@click.option(
+    "--priority",
+    "-p",
+    type=int,
+    default=None,
+    help="Task priority (default: from config or 5, higher value = higher priority)",
+)
+@click.option(
+    "--fixed",
+    "-f",
+    is_flag=True,
+    help="Mark task as fixed (won't be rescheduled by optimizer)",
+)
+@click.option(
+    "--depends-on",
+    "-d",
+    multiple=True,
+    type=int,
+    help="Task IDs this task depends on (can be specified multiple times)",
+)
+@click.option(
+    "--tag",
+    "-t",
+    multiple=True,
+    type=str,
+    help="Tags for categorization and filtering (can be specified multiple times)",
+)
+@click.option(
+    "--deadline",
+    "-D",
+    type=click.DateTime(formats=["%Y-%m-%d %H:%M:%S"]),
+    default=None,
+    help="Task deadline (format: YYYY-MM-DD HH:MM:SS)",
+)
+@click.option(
+    "--estimate",
+    "-e",
+    type=float,
+    default=None,
+    help="Estimated duration in hours (must be > 0)",
+)
+@click.option(
+    "--start",
+    "-s",
+    type=click.DateTime(formats=["%Y-%m-%d %H:%M:%S"]),
+    default=None,
+    help="Planned start time (format: YYYY-MM-DD HH:MM:SS)",
+)
+@click.option(
+    "--end",
+    "-E",
+    type=click.DateTime(formats=["%Y-%m-%d %H:%M:%S"]),
+    default=None,
+    help="Planned end time (format: YYYY-MM-DD HH:MM:SS)",
+)
+@click.pass_context
+@handle_task_errors("adding task")
+def add_command(
+    ctx: click.Context,
+    name: str,
+    priority: int,
+    fixed: bool,
+    depends_on: tuple[int, ...],
+    tag: tuple[str, ...],
+    deadline: datetime | None,
+    estimate: float | None,
+    start: datetime | None,
+    end: datetime | None,
+) -> None:
+    """Add a new task.
+
+    You can set all task properties at creation time, or use dedicated commands
+    after creation (deadline, estimate, schedule) for updates.
+
+    Usage:
+        # Basic task
+        taskdog add "Task name"
+
+        # With priority and tags
+        taskdog add "Task name" --priority 3 --tag backend
+
+        # Full task with all properties
+        taskdog add "Implement auth" -p 5 -D "2025-12-01" -e 8 -s "2025-11-20" -t backend
+
+    Examples:
+        # Simple task
+        taskdog add "Implement authentication"
+
+        # With priority
+        taskdog add "Fix login bug" -p 5
+
+        # With deadline and estimate
+        taskdog add "Add unit tests" --deadline "2025-12-15" --estimate 4
+
+        # Complete task with schedule
+        taskdog add "Code review" -p 3 -s "2025-11-20 09:00" -e "2025-11-20 12:00"
+
+        # With dependencies and tags
+        taskdog add "Deploy feature" -d 123 -t deployment -p 5
+    """
+    ctx_obj: CliContext = ctx.obj
+    console_writer = ctx_obj.console_writer
+
+    # Create task via API client
+    task = ctx_obj.api_client.create_task(
+        name=name,
+        priority=priority,
+        is_fixed=fixed,
+        tags=list(tag) if tag else None,
+        deadline=deadline,
+        estimated_duration=estimate,
+        planned_start=start,
+        planned_end=end,
+    )
+
+    # Add dependencies if specified
+    if depends_on:
+        for dep_id in depends_on:
+            try:
+                task = ctx_obj.api_client.add_dependency(task.id, dep_id)
+            except TaskValidationError as e:
+                console_writer.validation_error(str(e))
+                # Continue adding other dependencies even if one fails
+
+    console_writer.task_success("Added", task)
+    if task.depends_on:
+        console_writer.info(f"Dependencies: {task.depends_on}")
+    if task.tags:
+        console_writer.info(f"Tags: {', '.join(task.tags)}")

taskdog/cli/commands/add_dependency.py

@@ -0,0 +1,40 @@
+"""Add-dependency command - Add a task dependency."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import click
+
+from taskdog.cli.error_handler import handle_task_errors
+
+if TYPE_CHECKING:
+    from taskdog.cli.context import CliContext
+
+
+@click.command(name="add-dependency", help="Add a dependency to a task.")
+@click.argument("task_id", type=int)
+@click.argument("depends_on_id", type=int)
+@click.pass_context
+@handle_task_errors("adding dependency")
+def add_dependency_command(
+    ctx: click.Context, task_id: int, depends_on_id: int
+) -> None:
+    """Add a dependency to a task.
+
+    Usage:
+        taskdog add-dependency <TASK_ID> <DEPENDS_ON_ID>
+
+    Examples:
+        taskdog add-dependency 5 3    # Task 5 depends on task 3
+    """
+    ctx_obj: CliContext = ctx.obj
+    console_writer = ctx_obj.console_writer
+
+    # Add dependency via API client
+    task = ctx_obj.api_client.add_dependency(task_id, depends_on_id)
+
+    console_writer.success(
+        f"Added dependency: Task {task_id} now depends on task {depends_on_id}"
+    )
+    console_writer.info(f"Task {task_id} dependencies: {task.depends_on}")

taskdog/cli/commands/audit_logs.py

@@ -0,0 +1,226 @@
+"""Audit logs command - Display operation history."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+import click
+from rich.table import Table
+
+from taskdog.cli.error_handler import handle_command_errors
+from taskdog.constants.audit_log import (
+    AUDIT_CHANGES_WIDTH,
+    AUDIT_CLIENT_WIDTH,
+    AUDIT_ID_WIDTH,
+    AUDIT_OPERATION_WIDTH,
+    AUDIT_STATUS_WIDTH,
+    AUDIT_TIMESTAMP_WIDTH,
+    COLUMN_AUDIT_ID_STYLE,
+    COLUMN_AUDIT_STATUS_FAIL_STYLE,
+    COLUMN_AUDIT_STATUS_OK_STYLE,
+    HEADER_AUDIT_CHANGES,
+    HEADER_AUDIT_CLIENT,
+    HEADER_AUDIT_OPERATION,
+    HEADER_AUDIT_RESOURCE,
+    HEADER_AUDIT_STATUS,
+    HEADER_AUDIT_TIMESTAMP,
+    JUSTIFY_AUDIT_CHANGES,
+)
+from taskdog.constants.common import HEADER_ID, TABLE_HEADER_STYLE
+from taskdog.constants.formatting import format_table_title
+from taskdog.tui.widgets.audit_log_entry_builder import format_audit_changes
+
+if TYPE_CHECKING:
+    from taskdog.cli.context import CliContext
+    from taskdog_core.application.dto.audit_log_dto import AuditLogOutput
+
+
+def _parse_date_filter(date_str: str, end_of_day: bool = False) -> datetime:
+    """Parse a date filter string to datetime.
+
+    Args:
+        date_str: ISO format date or datetime string
+        end_of_day: If True and only date provided, use end of day
+
+    Returns:
+        Parsed datetime object
+    """
+    try:
+        return datetime.fromisoformat(date_str)
+    except ValueError:
+        suffix = "T23:59:59" if end_of_day else "T00:00:00"
+        return datetime.fromisoformat(f"{date_str}{suffix}")
+
+
+def _format_resource(log: AuditLogOutput) -> str:
+    """Format resource display for audit log entry."""
+    if log.resource_id and log.resource_name:
+        return f"[cyan]#{log.resource_id}[/cyan] {log.resource_name}"
+    if log.resource_id:
+        return f"[cyan]#{log.resource_id}[/cyan]"
+    if log.resource_name:
+        return log.resource_name
+    return "[dim]-[/dim]"
+
+
+def _format_changes(log: AuditLogOutput) -> str:
+    """Format changes display for audit log entry."""
+    if not log.success and log.error_message:
+        error_msg = log.error_message[:AUDIT_CHANGES_WIDTH]
+        if len(log.error_message) > AUDIT_CHANGES_WIDTH:
+            error_msg += "..."
+        return f"[red]{error_msg}[/red]"
+    return format_audit_changes(
+        log.old_values, log.new_values, max_length=AUDIT_CHANGES_WIDTH
+    )
+
+
+@click.command(
+    name="audit-logs",
+    help="""Display operation history (audit logs).
+
+Shows a history of operations performed via the API, including task creates,
+updates, status changes, and other modifications.
+
+Use filters to narrow down the logs by client name, operation type, task ID, etc.
+
+Examples:
+  taskdog audit-logs                           # Show latest 100 logs
+  taskdog audit-logs --client claude-code      # Filter by client
+  taskdog audit-logs --task 123                # Filter by task ID
+  taskdog audit-logs --operation complete_task # Filter by operation
+  taskdog audit-logs --since 2025-12-01        # Filter by date
+""",
+)
+@click.option(
+    "--client",
+    "-c",
+    "client_filter",
+    type=str,
+    default=None,
+    help="Filter by client name (e.g., 'claude-code')",
+)
+@click.option(
+    "--operation",
+    "-o",
+    type=str,
+    default=None,
+    help="Filter by operation type (e.g., 'create_task', 'complete_task')",
+)
+@click.option(
+    "--task",
+    "-t",
+    "task_id",
+    type=int,
+    default=None,
+    help="Filter by task ID",
+)
+@click.option(
+    "--since",
+    type=str,
+    default=None,
+    help="Show logs since this date (ISO format: YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS)",
+)
+@click.option(
+    "--until",
+    type=str,
+    default=None,
+    help="Show logs until this date (ISO format: YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS)",
+)
+@click.option(
+    "--limit",
+    "-n",
+    type=click.IntRange(1, 1000),
+    default=100,
+    help="Maximum number of logs to show (default: 100, max: 1000)",
+)
+@click.option(
+    "--failed",
+    is_flag=True,
+    default=False,
+    help="Show only failed operations",
+)
+@click.pass_context
+@handle_command_errors("fetching audit logs")
+def audit_logs_command(
+    ctx: click.Context,
+    client_filter: str | None,
+    operation: str | None,
+    task_id: int | None,
+    since: str | None,
+    until: str | None,
+    limit: int,
+    failed: bool,
+) -> None:
+    """Display operation history (audit logs)."""
+    ctx_obj: CliContext = ctx.obj
+    console_writer = ctx_obj.console_writer
+    api_client = ctx_obj.api_client
+
+    # Parse date filters
+    start_date = _parse_date_filter(since) if since else None
+    end_date = _parse_date_filter(until, end_of_day=True) if until else None
+
+    # Fetch audit logs via API
+    result = api_client.list_audit_logs(
+        client_filter=client_filter,
+        operation=operation,
+        resource_type="task" if task_id else None,
+        resource_id=task_id,
+        success=False if failed else None,
+        start_date=start_date,
+        end_date=end_date,
+        limit=limit,
+    )
+
+    if not result.logs:
+        console_writer.info("No audit logs found matching the criteria.")
+        return
+
+    # Create Rich table
+    table = Table(
+        title=format_table_title(
+            f"Audit Logs ({len(result.logs)} of {result.total_count})"
+        ),
+        show_header=True,
+        header_style=TABLE_HEADER_STYLE,
+    )
+    table.add_column(HEADER_ID, style=COLUMN_AUDIT_ID_STYLE, width=AUDIT_ID_WIDTH)
+    table.add_column(HEADER_AUDIT_TIMESTAMP, width=AUDIT_TIMESTAMP_WIDTH)
+    table.add_column(HEADER_AUDIT_RESOURCE)
+    table.add_column(HEADER_AUDIT_OPERATION, width=AUDIT_OPERATION_WIDTH)
+    table.add_column(
+        HEADER_AUDIT_CHANGES,
+        width=AUDIT_CHANGES_WIDTH,
+        justify=JUSTIFY_AUDIT_CHANGES,
+    )
+    table.add_column(HEADER_AUDIT_CLIENT, width=AUDIT_CLIENT_WIDTH)
+    table.add_column(HEADER_AUDIT_STATUS, width=AUDIT_STATUS_WIDTH)
+
+    for log in result.logs:
+        status_style = (
+            COLUMN_AUDIT_STATUS_OK_STYLE
+            if log.success
+            else COLUMN_AUDIT_STATUS_FAIL_STYLE
+        )
+        status_label = "OK" if log.success else "FAILED"
+        changes = _format_changes(log)
+        table.add_row(
+            str(log.id),
+            log.timestamp.strftime("%Y-%m-%d %H:%M:%S"),
+            _format_resource(log),
+            log.operation,
+            changes,
+            log.client_name or "[dim]anonymous[/dim]",
+            f"[{status_style}]{status_label}[/{status_style}]",
+        )
+
+    console_writer.print(table)
+
+    # Show pagination info if there are more logs
+    if result.total_count > len(result.logs):
+        console_writer.info(
+            f"Showing {len(result.logs)} of {result.total_count} logs. "
+            f"Use --limit to see more."
+        )

taskdog/cli/commands/cancel.py

@@ -0,0 +1,29 @@
+"""Cancel command - Mark a task as canceled."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import click
+
+if TYPE_CHECKING:
+    from taskdog.cli.context import CliContext
+from taskdog_core.shared.constants import StatusVerbs
+
+
+@click.command(name="cancel", help="Mark task(s) as canceled.")
+@click.argument("task_ids", nargs=-1, type=int, required=True)
+@click.pass_context
+def cancel_command(ctx: click.Context, task_ids: tuple[int, ...]) -> None:
+    """Mark task(s) as canceled."""
+    ctx_obj: CliContext = ctx.obj
+    console_writer = ctx_obj.console_writer
+
+    results = ctx_obj.api_client.bulk_cancel(list(task_ids))
+    for result in results.results:
+        if result.success and result.task is not None:
+            console_writer.task_success(StatusVerbs.CANCELED, result.task)
+        elif result.error is not None:
+            console_writer.validation_error(result.error)
+        if len(task_ids) > 1:
+            console_writer.empty_line()

taskdog/cli/commands/common_options.py

@@ -0,0 +1,116 @@
+"""Common CLI option decorators for reuse across commands."""
+
+from collections.abc import Callable
+from functools import wraps
+from typing import Any
+
+import click
+
+
+def filter_options() -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Add common filter options (--all, --status) to a command.
+
+    Usage:
+        @click.command()
+        @filter_options()
+        def my_command(ctx, include_archived, status, ...):
+            pass
+    """
+
+    def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
+        @click.option(
+            "--status",
+            type=click.Choice(
+                ["pending", "in_progress", "completed", "canceled"],
+                case_sensitive=False,
+            ),
+            default=None,
+            help="Filter tasks by status (overrides --all). Note: archived tasks are controlled by the --all flag, not --status.",
+        )
+        @click.option(
+            "--all",
+            "-a",
+            "include_archived",
+            is_flag=True,
+            help="Show all tasks including completed, canceled, and archived",
+        )
+        @wraps(f)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            return f(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def sort_options(
+    default_sort: str = "id",
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Add common sort options (--sort, --reverse) to a command.
+
+    Args:
+        default_sort: Default field to sort by (default: "id")
+
+    Usage:
+        @click.command()
+        @sort_options(default_sort="deadline")
+        def my_command(ctx, sort, reverse, ...):
+            pass
+    """
+
+    def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
+        @click.option(
+            "--reverse",
+            "-r",
+            is_flag=True,
+            help="Reverse sort order",
+        )
+        @click.option(
+            "--sort",
+            type=click.Choice(
+                ["id", "priority", "deadline", "name", "status", "planned_start"]
+            ),
+            default=default_sort,
+            help=f"Sort tasks by specified field (default: {default_sort})",
+        )
+        @wraps(f)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            return f(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def date_range_options() -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Add common date range options (--start-date, --end-date) to a command.
+
+    Usage:
+        @click.command()
+        @date_range_options()
+        def my_command(ctx, start_date, end_date, ...):
+            pass
+    """
+
+    def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
+        @click.option(
+            "--end-date",
+            "-e",
+            type=click.DateTime(),
+            help="End date for filtering (YYYY-MM-DD). "
+            "Shows tasks with any date field <= end date.",
+        )
+        @click.option(
+            "--start-date",
+            "-s",
+            type=click.DateTime(),
+            help="Start date for filtering (YYYY-MM-DD). "
+            "Shows tasks with any date field >= start date.",
+        )
+        @wraps(f)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            return f(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

taskdog/cli/commands/done.py

@@ -0,0 +1,30 @@
+"""Done command - Mark a task as completed."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import click
+
+if TYPE_CHECKING:
+    from taskdog.cli.context import CliContext
+from taskdog_core.shared.constants import StatusVerbs
+
+
+@click.command(name="done", help="Mark task(s) as completed.")
+@click.argument("task_ids", nargs=-1, type=int, required=True)
+@click.pass_context
+def done_command(ctx: click.Context, task_ids: tuple[int, ...]) -> None:
+    """Mark task(s) as completed."""
+    ctx_obj: CliContext = ctx.obj
+    console_writer = ctx_obj.console_writer
+
+    results = ctx_obj.api_client.bulk_complete(list(task_ids))
+    for result in results.results:
+        if result.success and result.task is not None:
+            console_writer.task_success(StatusVerbs.COMPLETED, result.task)
+            console_writer.task_completion_details(result.task)
+        elif result.error is not None:
+            console_writer.validation_error(result.error)
+        if len(task_ids) > 1:
+            console_writer.empty_line()