mojentic 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

mojentic/llm/tools/ephemeral_task_manager/append_task_tool_spec.py

@@ -0,0 +1,34 @@
+from unittest.mock import Mock
+
+import pytest
+
+from mojentic.llm.tools.ephemeral_task_manager.append_task_tool import AppendTaskTool
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList, Task, TaskStatus
+
+
+@pytest.fixture
+def mock_task_list():
+    mock = Mock(spec=EphemeralTaskList)
+    return mock
+
+
+@pytest.fixture
+def append_task_tool(mock_task_list):
+    return AppendTaskTool(task_list=mock_task_list)
+
+
+class DescribeAppendTaskTool:
+    def should_call_append_task_with_description(self, append_task_tool, mock_task_list):
+        mock_task = Task(id=1, description="Test task", status=TaskStatus.PENDING)
+        mock_task_list.append_task.return_value = mock_task
+
+        append_task_tool.run(description="Test task")
+
+        mock_task_list.append_task.assert_called_once_with(description="Test task")
+
+    def should_handle_error_when_append_task_fails(self, append_task_tool, mock_task_list):
+        mock_task_list.append_task.side_effect = ValueError("Test error")
+
+        append_task_tool.run(description="Test task")
+
+        mock_task_list.append_task.assert_called_once_with(description="Test task")

mojentic/llm/tools/ephemeral_task_manager/clear_tasks_tool.py

@@ -0,0 +1,57 @@
+"""
+Tool for clearing all tasks from the ephemeral task manager.
+"""
+
+from typing import Dict
+
+from mojentic.llm.tools.llm_tool import LLMTool
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList
+
+
+class ClearTasksTool(LLMTool):
+    """
+    Tool for clearing all tasks from the ephemeral task manager.
+    """
+
+    def __init__(self, task_list: EphemeralTaskList):
+        """
+        Initialize the tool with a shared task list.
+
+        Args:
+            task_list: The shared task list to use
+        """
+        self._task_list = task_list
+
+    def run(self) -> Dict[str, str]:
+        """
+        Remove all tasks from the list.
+
+        Returns:
+            A dictionary with the result of the operation
+        """
+        count = self._task_list.clear_tasks()
+        return {
+            "count": str(count),
+            "summary": f"Cleared {count} tasks from the list"
+        }
+
+    @property
+    def descriptor(self):
+        """
+        Get the descriptor for the tool.
+
+        Returns:
+            The descriptor dictionary
+        """
+        return {
+            "type": "function",
+            "function": {
+                "name": "clear_tasks",
+                "description": "Remove all tasks from the task list.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {},
+                    "additionalProperties": False
+                }
+            }
+        }

mojentic/llm/tools/ephemeral_task_manager/clear_tasks_tool_spec.py

@@ -0,0 +1,32 @@
+import pytest
+from unittest.mock import Mock
+
+from mojentic.llm.tools.ephemeral_task_manager.clear_tasks_tool import ClearTasksTool
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList
+
+
+@pytest.fixture
+def mock_task_list():
+    mock = Mock(spec=EphemeralTaskList)
+    return mock
+
+
+@pytest.fixture
+def clear_tasks_tool(mock_task_list):
+    return ClearTasksTool(task_list=mock_task_list)
+
+
+class DescribeClearTasksTool:
+    def should_call_clear_tasks(self, clear_tasks_tool, mock_task_list):
+        mock_task_list.clear_tasks.return_value = 3  # Simulate clearing 3 tasks
+
+        clear_tasks_tool.run()
+
+        mock_task_list.clear_tasks.assert_called_once()
+
+    def should_handle_empty_list(self, clear_tasks_tool, mock_task_list):
+        mock_task_list.clear_tasks.return_value = 0  # Simulate clearing 0 tasks
+
+        clear_tasks_tool.run()
+
+        mock_task_list.clear_tasks.assert_called_once()

mojentic/llm/tools/ephemeral_task_manager/complete_task_tool.py

@@ -0,0 +1,81 @@
+"""
+Tool for completing a task in the ephemeral task manager.
+"""
+
+from typing import Dict
+
+from mojentic.llm.tools.llm_tool import LLMTool
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList
+
+
+class CompleteTaskTool(LLMTool):
+    """
+    Tool for completing a task in the ephemeral task manager.
+
+    This tool changes a task's status from IN_PROGRESS to COMPLETED.
+    """
+
+    def __init__(self, task_list: EphemeralTaskList):
+        """
+        Initialize the tool with a shared task list.
+
+        Args:
+            task_list: The shared task list to use
+        """
+        self._task_list = task_list
+
+    def run(self, id: int) -> Dict[str, str]:
+        """
+        Complete a task by changing its status from IN_PROGRESS to COMPLETED.
+
+        Args:
+            id: The ID of the task to complete
+
+        Returns:
+            A dictionary with the result of the operation
+
+        Raises:
+            ValueError: If no task with the given ID exists or if the task is not in IN_PROGRESS status
+        """
+        try:
+            # Convert id to int if it's a string
+            task_id = int(id) if isinstance(id, str) else id
+            task = self._task_list.complete_task(id=task_id)
+            return {
+                "id": task.id,
+                "description": task.description,
+                "status": task.status.value,
+                "summary": f"Task '{id}' completed successfully"
+            }
+        except ValueError as e:
+            return {
+                "error": str(e),
+                "summary": f"Failed to complete task: {str(e)}"
+            }
+
+    @property
+    def descriptor(self):
+        """
+        Get the descriptor for the tool.
+
+        Returns:
+            The descriptor dictionary
+        """
+        return {
+            "type": "function",
+            "function": {
+                "name": "complete_task",
+                "description": "Complete a task by changing its status from IN_PROGRESS to COMPLETED.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "id": {
+                            "type": "integer",
+                            "description": "The ID of the task to complete"
+                        }
+                    },
+                    "required": ["id"],
+                    "additionalProperties": False
+                }
+            }
+        }

mojentic/llm/tools/ephemeral_task_manager/complete_task_tool_spec.py

@@ -0,0 +1,43 @@
+from unittest.mock import Mock
+
+import pytest
+
+from mojentic.llm.tools.ephemeral_task_manager.complete_task_tool import CompleteTaskTool
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList, Task, TaskStatus
+
+
+@pytest.fixture
+def mock_task_list():
+    mock = Mock(spec=EphemeralTaskList)
+    return mock
+
+
+@pytest.fixture
+def complete_task_tool(mock_task_list):
+    return CompleteTaskTool(task_list=mock_task_list)
+
+
+class DescribeCompleteTaskTool:
+    def should_call_complete_task_with_correct_id(self, complete_task_tool, mock_task_list):
+        mock_task = Task(id=1, description="Test task", status=TaskStatus.COMPLETED)
+        mock_task_list.complete_task.return_value = mock_task
+
+        complete_task_tool.run(id=1)
+
+        mock_task_list.complete_task.assert_called_once_with(id=1)
+
+    def should_convert_string_id_to_int(self, complete_task_tool, mock_task_list):
+        mock_task = Task(id=1, description="Test task", status=TaskStatus.COMPLETED)
+        mock_task_list.complete_task.return_value = mock_task
+
+        complete_task_tool.run(id="1")
+
+        mock_task_list.complete_task.assert_called_once_with(id=1)
+
+    def should_handle_error_when_complete_task_fails(self, complete_task_tool, mock_task_list):
+        error_message = "Task '1' cannot be completed because it is not in IN_PROGRESS status"
+        mock_task_list.complete_task.side_effect = ValueError(error_message)
+
+        complete_task_tool.run(id=1)
+
+        mock_task_list.complete_task.assert_called_once_with(id=1)

mojentic/llm/tools/ephemeral_task_manager/ephemeral_task_list.py

@@ -0,0 +1,202 @@
+"""
+Task list for the ephemeral task manager.
+
+This module provides a class for managing a list of tasks with state transitions.
+"""
+
+from enum import Enum
+from typing import List, Optional
+from pydantic import BaseModel
+
+
+class TaskStatus(str, Enum):
+    """
+    Enumeration of possible task statuses.
+
+    Tasks follow a state machine that transitions from PENDING through IN_PROGRESS to COMPLETED.
+    """
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+
+
+class Task(BaseModel):
+    """
+    Represents a task with an identifier, description, and status.
+    """
+    id: int
+    description: str
+    status: TaskStatus = TaskStatus.PENDING
+
+
+class EphemeralTaskList:
+    """
+    Manages a list of tasks for the ephemeral task manager.
+
+    This class provides methods for adding, starting, completing, and listing tasks.
+    Tasks follow a state machine that transitions from PENDING through IN_PROGRESS to COMPLETED.
+    """
+
+    def __init__(self):
+        """
+        Initialize an empty task list and ID counter.
+        """
+        self._tasks: List[Task] = []
+        self._next_id: int = 1
+
+    def _claim_next_id(self) -> int:
+        """
+        Claim the next available ID and increment the counter.
+
+        Returns:
+            The claimed ID
+        """
+        id = self._next_id
+        self._next_id += 1
+        return id
+
+    def append_task(self, description: str) -> Task:
+        """
+        Add a new task to the end of the list.
+
+        Args:
+            description: The description of the task
+
+        Returns:
+            The newly created task with PENDING status
+        """
+        # Generate a new ID
+        id = self._claim_next_id()
+
+        task = Task(id=id, description=description, status=TaskStatus.PENDING)
+        self._tasks.append(task)
+        return task
+
+    def prepend_task(self, description: str) -> Task:
+        """
+        Add a new task to the beginning of the list.
+
+        Args:
+            description: The description of the task
+
+        Returns:
+            The newly created task with PENDING status
+        """
+        # Generate a new ID
+        id = self._claim_next_id()
+
+        task = Task(id=id, description=description, status=TaskStatus.PENDING)
+        self._tasks.insert(0, task)
+        return task
+
+    def insert_task_after(self, existing_task_id: int, description: str) -> Task:
+        """
+        Insert a new task after an existing task.
+
+        Args:
+            existing_task_id: The ID of the existing task after which to insert the new task
+            description: The description of the new task
+
+        Returns:
+            The newly created task with PENDING status
+
+        Raises:
+            ValueError: If no task with the given ID exists
+        """
+        # Find the position of the existing task
+        position = None
+        for i, task in enumerate(self._tasks):
+            if task.id == existing_task_id:
+                position = i
+                break
+
+        if position is None:
+            raise ValueError(f"No task with ID '{existing_task_id}' exists")
+
+        # Generate a new ID
+        id = self._claim_next_id()
+
+        task = Task(id=id, description=description, status=TaskStatus.PENDING)
+        self._tasks.insert(position + 1, task)
+        return task
+
+    def start_task(self, id: int) -> Task:
+        """
+        Start a task by changing its status from PENDING to IN_PROGRESS.
+
+        Args:
+            id: The ID of the task to start
+
+        Returns:
+            The started task
+
+        Raises:
+            ValueError: If no task with the given ID exists or if the task is not in PENDING status
+        """
+        task = self._get_task(id)
+
+        if task.status != TaskStatus.PENDING:
+            raise ValueError(f"Task '{id}' cannot be started because it is not in PENDING status")
+
+        task.status = TaskStatus.IN_PROGRESS
+        return task
+
+    def complete_task(self, id: int) -> Task:
+        """
+        Complete a task by changing its status from IN_PROGRESS to COMPLETED.
+
+        Args:
+            id: The ID of the task to complete
+
+        Returns:
+            The completed task
+
+        Raises:
+            ValueError: If no task with the given ID exists or if the task is not in IN_PROGRESS status
+        """
+        task = self._get_task(id)
+
+        if task.status != TaskStatus.IN_PROGRESS:
+            raise ValueError(f"Task '{id}' cannot be completed because it is not in IN_PROGRESS status")
+
+        task.status = TaskStatus.COMPLETED
+        return task
+
+    def list_tasks(self) -> List[Task]:
+        """
+        Get all tasks in the list.
+
+        Returns:
+            A list of all tasks
+        """
+        return self._tasks.copy()
+
+    def clear_tasks(self) -> int:
+        """
+        Remove all tasks from the list.
+
+        Returns:
+            The number of tasks that were cleared
+        """
+        count = len(self._tasks)
+        self._tasks = []
+        return count
+
+    def _get_task(self, id: int) -> Task:
+        """
+        Get a task by its ID.
+
+        Args:
+            id: The ID of the task to get
+
+        Returns:
+            The task with the given ID
+
+        Raises:
+            ValueError: If no task with the given ID exists
+        """
+        for task in self._tasks:
+            if task.id == id:
+                return task
+
+        raise ValueError(f"No task with ID '{id}' exists")

mojentic/llm/tools/ephemeral_task_manager/ephemeral_task_list_spec.py

@@ -0,0 +1,137 @@
+import pytest
+
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList, TaskStatus
+
+
+@pytest.fixture
+def task_list():
+    return EphemeralTaskList()
+
+
+@pytest.fixture
+def populated_task_list():
+    task_list = EphemeralTaskList()
+    task_list.append_task("Task 1")
+    task_list.append_task("Task 2")
+    task_list.append_task("Task 3")
+    return task_list
+
+
+class DescribeEphemeralTaskList:
+
+    def should_initialize_with_empty_task_list(self, task_list):
+        tasks = task_list.list_tasks()
+        assert len(tasks) == 0
+
+    def should_append_task(self, task_list):
+        task = task_list.append_task("Test task")
+
+        tasks = task_list.list_tasks()
+        assert len(tasks) == 1
+        assert tasks[0].id == task.id
+        assert tasks[0].description == "Test task"
+        assert tasks[0].status == TaskStatus.PENDING
+
+    def should_prepend_task(self, task_list):
+        task_list.append_task("Existing task")
+        task = task_list.prepend_task("New task")
+
+        tasks = task_list.list_tasks()
+        assert len(tasks) == 2
+        assert tasks[0].id == task.id
+        assert tasks[0].description == "New task"
+        assert tasks[0].status == TaskStatus.PENDING
+
+    def should_insert_task_after(self, populated_task_list):
+        tasks_before = populated_task_list.list_tasks()
+        existing_task_id = tasks_before[1].id
+
+        task = populated_task_list.insert_task_after(existing_task_id, "Inserted task")
+
+        tasks_after = populated_task_list.list_tasks()
+        assert len(tasks_after) == 4
+        assert tasks_after[2].id == task.id
+        assert tasks_after[2].description == "Inserted task"
+        assert tasks_after[2].status == TaskStatus.PENDING
+
+    def should_raise_error_when_inserting_after_nonexistent_task(self, task_list):
+        with pytest.raises(ValueError) as e:
+            task_list.insert_task_after(999, "This should fail")
+
+        assert "No task with ID '999' exists" in str(e.value)
+
+    def should_start_task(self, populated_task_list):
+        tasks = populated_task_list.list_tasks()
+        task_id = tasks[0].id
+
+        started_task = populated_task_list.start_task(task_id)
+
+        assert started_task.status == TaskStatus.IN_PROGRESS
+
+    def should_raise_error_when_starting_non_pending_task(self, populated_task_list):
+        tasks = populated_task_list.list_tasks()
+        task_id = tasks[0].id
+
+        populated_task_list.start_task(task_id)
+
+        # Second start should fail
+        with pytest.raises(ValueError) as e:
+            populated_task_list.start_task(task_id)
+
+        assert f"Task '{task_id}' cannot be started because it is not in PENDING status" in str(e.value)
+
+    def should_complete_task(self, populated_task_list):
+        tasks = populated_task_list.list_tasks()
+        task_id = tasks[0].id
+
+        # Start the task first
+        populated_task_list.start_task(task_id)
+
+        # Now complete it
+        completed_task = populated_task_list.complete_task(task_id)
+
+        assert completed_task.status == TaskStatus.COMPLETED
+
+    def should_raise_error_when_completing_non_in_progress_task(self, populated_task_list):
+        tasks = populated_task_list.list_tasks()
+        task_id = tasks[0].id
+
+        with pytest.raises(ValueError) as excinfo:
+            populated_task_list.complete_task(task_id)
+
+        assert f"Task '{task_id}' cannot be completed because it is not in IN_PROGRESS status" in str(excinfo.value)
+
+    def should_clear_tasks(self, populated_task_list):
+        populated_task_list.clear_tasks()
+
+        tasks_after = populated_task_list.list_tasks()
+        assert len(tasks_after) == 0
+
+    def should_maintain_task_ids_across_operations(self, task_list):
+        # Add some tasks
+        task1 = task_list.append_task("Task 1")
+        task2 = task_list.append_task("Task 2")
+
+        # Start and complete task1
+        task_list.start_task(task1.id)
+        task_list.complete_task(task1.id)
+
+        # Add another task
+        task3 = task_list.append_task("Task 3")
+
+        # Verify all tasks have correct IDs and statuses
+        tasks = task_list.list_tasks()
+        assert len(tasks) == 3
+
+        # Find tasks by ID
+        task1_in_list = next((t for t in tasks if t.id == task1.id), None)
+        task2_in_list = next((t for t in tasks if t.id == task2.id), None)
+        task3_in_list = next((t for t in tasks if t.id == task3.id), None)
+
+        assert task1_in_list is not None
+        assert task2_in_list is not None
+        assert task3_in_list is not None
+
+        assert task1_in_list.status == TaskStatus.COMPLETED
+        assert task2_in_list.status == TaskStatus.PENDING
+        assert task3_in_list.status == TaskStatus.PENDING

mojentic/llm/tools/ephemeral_task_manager/insert_task_after_tool.py

@@ -0,0 +1,84 @@
+"""
+Tool for inserting a new task after an existing task in the ephemeral task manager list.
+"""
+
+from typing import Dict
+
+from mojentic.llm.tools.llm_tool import LLMTool
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList
+
+
+class InsertTaskAfterTool(LLMTool):
+    """
+    Tool for inserting a new task after an existing task in the ephemeral task manager list.
+    """
+
+    def __init__(self, task_list: EphemeralTaskList):
+        """
+        Initialize the tool with a shared task list.
+
+        Args:
+            task_list: The shared task list to use
+        """
+        self._task_list = task_list
+
+    def run(self, existing_task_id: int, description: str) -> Dict[str, str]:
+        """
+        Insert a new task after an existing task.
+
+        Args:
+            existing_task_id: The ID of the existing task after which to insert the new task
+            description: The description of the new task
+
+        Returns:
+            A dictionary with the result of the operation
+
+        Raises:
+            ValueError: If no task with the given ID exists
+        """
+        try:
+            # Convert existing_task_id to int if it's a string
+            task_id = int(existing_task_id) if isinstance(existing_task_id, str) else existing_task_id
+            task = self._task_list.insert_task_after(existing_task_id=task_id, description=description)
+            return {
+                "id": task.id,
+                "description": task.description,
+                "status": task.status.value,
+                "summary": f"Task '{task.id}' inserted after task '{existing_task_id}' successfully"
+            }
+        except ValueError as e:
+            return {
+                "error": str(e),
+                "summary": f"Failed to insert task: {str(e)}"
+            }
+
+    @property
+    def descriptor(self):
+        """
+        Get the descriptor for the tool.
+
+        Returns:
+            The descriptor dictionary
+        """
+        return {
+            "type": "function",
+            "function": {
+                "name": "insert_task_after",
+                "description": "Insert a new task after an existing task in the task list. The task will start with 'pending' status.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "existing_task_id": {
+                            "type": "integer",
+                            "description": "The ID of the existing task after which to insert the new task"
+                        },
+                        "description": {
+                            "type": "string",
+                            "description": "The description of the new task"
+                        }
+                    },
+                    "required": ["existing_task_id", "description"],
+                    "additionalProperties": False
+                }
+            }
+        }