cortexshift 0.1.0__py3-none-any.whl

cortexshift/application/task_service.py

@@ -0,0 +1,201 @@
+"""Application service managing Task lifecycle and active task pointer."""
+
+from cortexshift.domain.errors import (
+    NoActiveTaskError,
+    TaskAlreadyCompletedError,
+    TaskNotActivatableError,
+    TaskNotFoundError,
+)
+from cortexshift.domain.task import Task, TaskStatus
+from cortexshift.ports.state_store import StateStore
+
+
+class TaskService:
+    """Orchestrates persistent Task creation, updates, and activation transitions."""
+
+    def __init__(self, store: StateStore) -> None:
+        self.store = store
+
+    def start_task(
+        self,
+        project_id: str,
+        title: str,
+        objective: str,
+        requirements: list[str] | None = None,
+        constraints: list[str] | None = None,
+        set_active: bool = True,
+    ) -> Task:
+        """Create a new task, persist it, and optionally set it as the active task.
+
+        Args:
+            project_id: Canonical ID of the owning project.
+            title: Short descriptive task title.
+            objective: High-level goal and scope of the task.
+            requirements: Optional initial list of requirement strings.
+            constraints: Optional initial list of constraint strings.
+            set_active: Whether to set this task as active immediately (defaults to True).
+
+        Returns:
+            The created Task entity.
+        """
+        initial_status = TaskStatus.IN_PROGRESS if set_active else TaskStatus.PENDING
+        task = Task(
+            project_id=project_id,
+            title=title,
+            objective=objective,
+            requirements=requirements or [],
+            constraints=constraints or [],
+            status=initial_status,
+        )
+
+        self.store.save_task(task)
+        if set_active:
+            self.store.set_active_task_id(project_id, task.id)
+        return task
+
+    def get_task(self, task_id: str) -> Task:
+        """Retrieve a task by identifier.
+
+        Raises:
+            TaskNotFoundError: If the task does not exist.
+        """
+        task = self.store.get_task(task_id)
+        if task is None:
+            raise TaskNotFoundError(task_id)
+        return task
+
+    def get_active_task(self, project_id: str) -> Task | None:
+        """Retrieve the currently active task for a project, or None if no task is active."""
+        active_id = self.store.get_active_task_id(project_id)
+        if active_id is None:
+            return None
+        return self.store.get_task(active_id)
+
+    def list_tasks(self, project_id: str) -> list[Task]:
+        """List all tasks associated with a project."""
+        return self.store.list_tasks(project_id)
+
+    def activate_task(self, project_id: str, task_id: str) -> Task:
+        """Make an existing task the active task for the project.
+
+        Args:
+            project_id: Canonical ID of the owning project.
+            task_id: Identifier of the task to activate.
+
+        Returns:
+            The newly activated Task entity.
+
+        Raises:
+            TaskNotFoundError: If the task does not exist or does not belong to the project.
+            TaskNotActivatableError: If the task is in a terminal status (completed/cancelled).
+        """
+        task = self.get_task(task_id)
+        if task.project_id != project_id:
+            raise TaskNotFoundError(task_id)
+
+        if task.is_terminal:
+            msg = (
+                f"Cannot activate task '{task_id}' because it is in terminal status "
+                f"'{task.status.value}'."
+            )
+            raise TaskNotActivatableError(msg)
+
+        self.store.set_active_task_id(project_id, task.id)
+        return task
+
+    def complete_task(self, project_id: str, task_id: str | None = None) -> Task:
+        """Mark a task as completed.
+
+        If task_id is None, the currently active task is completed.
+        If the completed task is currently active, the active task pointer is cleared.
+
+        Args:
+            project_id: Canonical ID of the owning project.
+            task_id: Optional identifier of the task to complete.
+
+        Returns:
+            The updated Task entity.
+
+        Raises:
+            NoActiveTaskError: If task_id is None and no task is currently active.
+            TaskNotFoundError: If the specified task does not exist.
+            TaskAlreadyCompletedError: If the task is already completed.
+        """
+        if task_id is None:
+            active_id = self.store.get_active_task_id(project_id)
+            if active_id is None:
+                raise NoActiveTaskError("No active task to complete.")
+            target_task = self.get_task(active_id)
+        else:
+            target_task = self.get_task(task_id)
+            if target_task.project_id != project_id:
+                raise TaskNotFoundError(task_id)
+
+        if target_task.status == TaskStatus.COMPLETED:
+            raise TaskAlreadyCompletedError(target_task.id)
+
+        completed_task = target_task.mark_completed()
+        self.store.save_task(completed_task)
+
+        # Clear active task pointer if this task was active
+        active_id = self.store.get_active_task_id(project_id)
+        if active_id == completed_task.id:
+            self.store.set_active_task_id(project_id, None)
+
+        return completed_task
+
+    def update_task(
+        self,
+        project_id: str,
+        task_id: str | None = None,
+        current_work: str | None = None,
+        clear_current_work: bool = False,
+        add_completed: list[str] | None = None,
+        add_remaining: list[str] | None = None,
+        add_issues: list[str] | None = None,
+    ) -> Task:
+        """Update fields and progression lists on a task.
+
+        Defaults to modifying the active task if task_id is None.
+
+        Args:
+            project_id: Canonical ID of the owning project.
+            task_id: Optional specific task identifier.
+            current_work: Optional new text describing in-flight work.
+            clear_current_work: If True, clears current_work to None.
+            add_completed: Optional list of completed item strings to append.
+            add_remaining: Optional list of remaining item strings to append.
+            add_issues: Optional list of known issue strings to append.
+
+        Returns:
+            The updated Task entity.
+
+        Raises:
+            NoActiveTaskError: If task_id is None and no task is active.
+            TaskNotFoundError: If the specified task does not exist.
+        """
+        if task_id is None:
+            active_id = self.store.get_active_task_id(project_id)
+            if active_id is None:
+                raise NoActiveTaskError("No active task to update.")
+            target_task = self.get_task(active_id)
+        else:
+            target_task = self.get_task(task_id)
+            if target_task.project_id != project_id:
+                raise TaskNotFoundError(task_id)
+
+        updated = target_task
+        if clear_current_work:
+            updated = updated.with_current_work(None)
+        elif current_work is not None:
+            updated = updated.with_current_work(current_work)
+
+        if add_completed:
+            updated = updated.add_completed_items(add_completed)
+        if add_remaining:
+            updated = updated.add_remaining_items(add_remaining)
+        if add_issues:
+            updated = updated.add_known_issues(add_issues)
+
+        self.store.save_task(updated)
+        return updated

cortexshift/application/task_workspace.py

@@ -0,0 +1,152 @@
+"""Project-root scoped Task operations with managed persistence lifecycle.
+
+`TaskService` operates on an already-open `StateStore`. Outer adapters that address a
+project by path — the TUI control center in particular — must not open SQLite themselves,
+so this service resolves the initialized project root, manages store lifecycle, and
+delegates every rule to `TaskService` and the canonical `Task` domain model.
+
+It contains no task business rules of its own.
+"""
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+
+from cortexshift.adapters.sqlite.store import SQLiteStateStore
+from cortexshift.application.locator import ProjectLocator
+from cortexshift.application.task_service import TaskService
+from cortexshift.domain.errors import NoActiveTaskError, ProjectNotInitializedError
+from cortexshift.domain.project import Project
+from cortexshift.domain.task import Task
+
+
+@dataclass(frozen=True)
+class ResolvedTaskWorkspace:
+    """An opened project workspace bound to a single canonical Project."""
+
+    project_root: Path
+    project: Project
+    tasks: TaskService
+
+
+class TaskWorkspaceService:
+    """Resolves a project by path and applies canonical Task operations to it."""
+
+    def __init__(self, project_locator: type[ProjectLocator] = ProjectLocator) -> None:
+        self._locator = project_locator
+
+    @contextmanager
+    def open(self, start_dir: Path | str | None = None) -> Iterator[ResolvedTaskWorkspace]:
+        """Open the nearest initialized project and yield its Task service.
+
+        Raises:
+            ProjectNotInitializedError: If no initialized project root is found.
+        """
+        start_path = Path(start_dir) if start_dir is not None else None
+        project_root = self._locator.find_project_root(start_path)
+        if project_root is None:
+            raise ProjectNotInitializedError()
+
+        db_path = self._locator.get_database_path(project_root)
+        store = SQLiteStateStore(db_path, auto_migrate=False)
+        try:
+            project = store.get_default_project()
+            if project is None:
+                raise ProjectNotInitializedError()
+            yield ResolvedTaskWorkspace(
+                project_root=project_root,
+                project=project,
+                tasks=TaskService(store),
+            )
+        finally:
+            store.close()
+
+    def list_tasks(self, start_dir: Path | str | None = None) -> list[Task]:
+        """List every Task belonging to the resolved project."""
+        with self.open(start_dir) as workspace:
+            return workspace.tasks.list_tasks(workspace.project.id)
+
+    def get_active_task(self, start_dir: Path | str | None = None) -> Task | None:
+        """Return the active Task for the resolved project, or None."""
+        with self.open(start_dir) as workspace:
+            return workspace.tasks.get_active_task(workspace.project.id)
+
+    def start_task(
+        self,
+        title: str,
+        objective: str,
+        requirements: list[str] | None = None,
+        constraints: list[str] | None = None,
+        set_active: bool = True,
+        start_dir: Path | str | None = None,
+    ) -> Task:
+        """Create a new Task using the canonical creation rules."""
+        with self.open(start_dir) as workspace:
+            return workspace.tasks.start_task(
+                project_id=workspace.project.id,
+                title=title,
+                objective=objective,
+                requirements=requirements,
+                constraints=constraints,
+                set_active=set_active,
+            )
+
+    def activate_task(self, task_id: str, start_dir: Path | str | None = None) -> Task:
+        """Activate an existing Task using canonical activation rules.
+
+        Raises:
+            TaskNotFoundError: If the Task does not belong to the resolved project.
+            TaskNotActivatableError: If the Task is in a terminal status.
+        """
+        with self.open(start_dir) as workspace:
+            return workspace.tasks.activate_task(workspace.project.id, task_id)
+
+    def set_current_work(
+        self,
+        current_work: str | None,
+        start_dir: Path | str | None = None,
+    ) -> Task:
+        """Replace the active Task's in-flight work description."""
+        with self.open(start_dir) as workspace:
+            return workspace.tasks.update_task(
+                project_id=workspace.project.id,
+                current_work=current_work,
+                clear_current_work=current_work is None,
+            )
+
+    def mark_completed(self, items: list[str], start_dir: Path | str | None = None) -> Task:
+        """Mark items completed on the active Task and drop them from remaining.
+
+        Applies the canonical `Task.complete_items` rule — the same rule MCP agents use —
+        so the Task itself is never completed as a side effect.
+        """
+        with self.open(start_dir) as workspace:
+            task = self._require_active(workspace)
+            updated = task.complete_items(items)
+            workspace.tasks.store.save_task(updated)
+            return updated
+
+    def add_remaining(self, items: list[str], start_dir: Path | str | None = None) -> Task:
+        """Append newly discovered remaining items to the active Task."""
+        with self.open(start_dir) as workspace:
+            return workspace.tasks.update_task(
+                project_id=workspace.project.id,
+                add_remaining=items,
+            )
+
+    def record_issues(self, items: list[str], start_dir: Path | str | None = None) -> Task:
+        """Record known issues or blockers on the active Task."""
+        with self.open(start_dir) as workspace:
+            return workspace.tasks.update_task(
+                project_id=workspace.project.id,
+                add_issues=items,
+            )
+
+    @staticmethod
+    def _require_active(workspace: ResolvedTaskWorkspace) -> Task:
+        """Return the active Task or fail with the canonical error."""
+        task = workspace.tasks.get_active_task(workspace.project.id)
+        if task is None:
+            raise NoActiveTaskError("No active task to update.")
+        return task

cortexshift/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI package for CortexShift."""
+
+from cortexshift.cli.app import app
+
+__all__ = ["app"]