solokit 0.1.1__py3-none-any.whl

solokit/work_items/repository.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""
+Work Item Repository - Data access and persistence layer.
+
+Handles CRUD operations for work items and milestones in work_items.json.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+from typing import Any, cast
+
+from solokit.core.cache import FileCache
+from solokit.core.file_ops import load_json, save_json
+from solokit.core.logging_config import get_logger
+from solokit.core.performance import measure_time
+from solokit.core.types import WorkItemStatus
+
+logger = get_logger(__name__)
+
+
+class WorkItemRepository:
+    """Repository for work item data access and persistence with caching"""
+
+    def __init__(self, session_dir: Path):
+        """Initialize repository with session directory
+
+        Args:
+            session_dir: Path to .session directory
+        """
+        self.session_dir = session_dir
+        self.work_items_file = session_dir / "tracking" / "work_items.json"
+        self._file_cache = FileCache()
+
+    @measure_time("load_work_items")
+    def load_all(self) -> dict[str, Any]:
+        """Load all work items and milestones from work_items.json with caching
+
+        Returns:
+            dict: Complete work items data including work_items and milestones
+        """
+        if not self.work_items_file.exists():
+            return {"work_items": {}, "milestones": {}}
+
+        return cast(dict[str, Any], self._file_cache.load_json(self.work_items_file, load_json))
+
+    def save_all(self, data: dict[str, Any]) -> None:
+        """Save all work items and milestones to work_items.json
+
+        Args:
+            data: Complete work items data to save
+        """
+        # Update metadata counters before saving
+        self._update_metadata(data)
+        save_json(self.work_items_file, data)
+        # Invalidate cache after write
+        self._file_cache.invalidate(self.work_items_file)
+
+    def get_work_item(self, work_id: str) -> dict[str, Any] | None:
+        """Get a single work item by ID
+
+        Args:
+            work_id: Work item ID
+
+        Returns:
+            dict: Work item data, or None if not found
+        """
+        data = self.load_all()
+        work_items = data.get("work_items", {})
+        result = work_items.get(work_id)
+        return result if result is None else dict(result)
+
+    def get_all_work_items(self) -> dict[str, Any]:
+        """Get all work items
+
+        Returns:
+            dict: All work items keyed by ID
+        """
+        data = self.load_all()
+        return dict(data.get("work_items", {}))
+
+    def work_item_exists(self, work_id: str) -> bool:
+        """Check if work item exists
+
+        Args:
+            work_id: Work item ID
+
+        Returns:
+            bool: True if work item exists
+        """
+        return self.get_work_item(work_id) is not None
+
+    def add_work_item(
+        self,
+        work_id: str,
+        work_type: str,
+        title: str,
+        priority: str,
+        dependencies: list[str],
+        spec_file: str = "",
+    ) -> None:
+        """Add a new work item to tracking
+
+        Args:
+            work_id: Unique work item ID
+            work_type: Type of work item
+            title: Work item title
+            priority: Priority level
+            dependencies: List of dependency IDs
+            spec_file: Relative path to spec file
+        """
+        data = self.load_all()
+
+        work_item = {
+            "id": work_id,
+            "type": work_type,
+            "title": title,
+            "status": WorkItemStatus.NOT_STARTED.value,
+            "priority": priority,
+            "dependencies": dependencies,
+            "milestone": "",
+            "spec_file": spec_file,
+            "created_at": datetime.now().isoformat(),
+            "sessions": [],
+        }
+
+        data.setdefault("work_items", {})[work_id] = work_item
+        self.save_all(data)
+        logger.info("Added work item: %s", work_id)
+
+    def update_work_item(self, work_id: str, updates: dict[str, Any]) -> None:
+        """Update a work item with new field values
+
+        Args:
+            work_id: Work item ID
+            updates: Dictionary of field updates
+        """
+        data = self.load_all()
+        items = data.get("work_items", {})
+
+        if work_id not in items:
+            return
+
+        item = items[work_id]
+
+        # Apply updates
+        for field, value in updates.items():
+            if field == "add_dependency":
+                deps = item.get("dependencies", [])
+                if value not in deps:
+                    deps.append(value)
+                    item["dependencies"] = deps
+            elif field == "remove_dependency":
+                deps = item.get("dependencies", [])
+                if value in deps:
+                    deps.remove(value)
+                    item["dependencies"] = deps
+            else:
+                item[field] = value
+
+        data["work_items"][work_id] = item
+        self.save_all(data)
+        logger.debug("Updated work item: %s", work_id)
+
+    def delete_work_item(self, work_id: str) -> bool:
+        """Delete a work item
+
+        Args:
+            work_id: Work item ID
+
+        Returns:
+            bool: True if deleted, False if not found
+        """
+        data = self.load_all()
+        items = data.get("work_items", {})
+
+        if work_id not in items:
+            return False
+
+        del items[work_id]
+        data["work_items"] = items
+        self.save_all(data)
+        logger.info("Deleted work item: %s", work_id)
+        return True
+
+    def get_milestone(self, name: str) -> dict[str, Any] | None:
+        """Get a milestone by name
+
+        Args:
+            name: Milestone name
+
+        Returns:
+            dict: Milestone data, or None if not found
+        """
+        data = self.load_all()
+        milestones = data.get("milestones", {})
+        result = milestones.get(name)
+        return result if result is None else dict(result)
+
+    def get_all_milestones(self) -> dict[str, Any]:
+        """Get all milestones
+
+        Returns:
+            dict: All milestones keyed by name
+        """
+        data = self.load_all()
+        return dict(data.get("milestones", {}))
+
+    def milestone_exists(self, name: str) -> bool:
+        """Check if milestone exists
+
+        Args:
+            name: Milestone name
+
+        Returns:
+            bool: True if milestone exists
+        """
+        return self.get_milestone(name) is not None
+
+    def add_milestone(
+        self, name: str, title: str, description: str, target_date: str | None = None
+    ) -> None:
+        """Add a new milestone
+
+        Args:
+            name: Unique milestone name
+            title: Milestone title
+            description: Milestone description
+            target_date: Optional target completion date
+        """
+        data = self.load_all()
+
+        milestone = {
+            "name": name,
+            "title": title,
+            "description": description,
+            "target_date": target_date or "",
+            "status": "not_started",
+            "created_at": datetime.now().isoformat(),
+        }
+
+        data.setdefault("milestones", {})[name] = milestone
+        self.save_all(data)
+        logger.info("Added milestone: %s", name)
+
+    def _update_metadata(self, data: dict[str, Any]) -> None:
+        """Update metadata counters
+
+        Args:
+            data: Work items data to update metadata for
+        """
+        if "metadata" not in data:
+            data["metadata"] = {}
+
+        work_items = data.get("work_items", {})
+        data["metadata"]["total_items"] = len(work_items)
+        data["metadata"]["completed"] = sum(
+            1 for item in work_items.values() if item["status"] == WorkItemStatus.COMPLETED.value
+        )
+        data["metadata"]["in_progress"] = sum(
+            1 for item in work_items.values() if item["status"] == WorkItemStatus.IN_PROGRESS.value
+        )
+        data["metadata"]["blocked"] = sum(
+            1 for item in work_items.values() if item["status"] == WorkItemStatus.BLOCKED.value
+        )
+        data["metadata"]["last_updated"] = datetime.now().isoformat()

solokit/work_items/scheduler.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+Work Item Scheduler - Work queue and next item selection.
+
+Handles finding the next work item to start based on dependencies and priority.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from solokit.core.logging_config import get_logger
+from solokit.core.types import Priority, WorkItemStatus
+
+if TYPE_CHECKING:
+    from .repository import WorkItemRepository
+from solokit.core.output import get_output
+
+logger = get_logger(__name__)
+output = get_output()
+
+
+class WorkItemScheduler:
+    """Handles work item scheduling and queue management"""
+
+    def __init__(self, repository: WorkItemRepository):
+        """Initialize scheduler with repository
+
+        Args:
+            repository: WorkItemRepository instance for data access
+        """
+        self.repository = repository
+
+    def get_next(self) -> dict[str, Any] | None:
+        """Find next work item to start based on dependencies and priority
+
+        Returns:
+            dict: Next work item to start, or None if none available
+        """
+        items = self.repository.get_all_work_items()
+
+        if not items:
+            output.info("No work items found.")
+            return None
+
+        # Filter to not_started items
+        not_started = {
+            wid: item
+            for wid, item in items.items()
+            if item["status"] == WorkItemStatus.NOT_STARTED.value
+        }
+
+        if not not_started:
+            output.info("No work items available to start.")
+            output.info("All items are either in progress or completed.")
+            return None
+
+        # Check dependencies and categorize
+        ready_items = []
+        blocked_items = []
+
+        for work_id, item in not_started.items():
+            is_blocked = self._is_blocked(item, items)
+            if is_blocked:
+                # Find what's blocking
+                blocking = [
+                    dep_id
+                    for dep_id in item.get("dependencies", [])
+                    if items.get(dep_id, {}).get("status") != WorkItemStatus.COMPLETED.value
+                ]
+                blocked_items.append((work_id, item, blocking))
+            else:
+                ready_items.append((work_id, item))
+
+        if not ready_items:
+            output.info("No work items ready to start. All have unmet dependencies.\n")
+            output.info("Blocked items:")
+            for work_id, item, blocking in blocked_items:
+                output.info(f"  🔴 {work_id} - Blocked by: {', '.join(blocking)}")
+            return None
+
+        # Sort ready items by priority
+        priority_order = {
+            Priority.CRITICAL.value: 0,
+            Priority.HIGH.value: 1,
+            Priority.MEDIUM.value: 2,
+            Priority.LOW.value: 3,
+        }
+        ready_items.sort(key=lambda x: priority_order.get(x[1]["priority"], 99))
+
+        # Get top item
+        next_id, next_item = ready_items[0]
+
+        # Display
+        self._display_next_item(next_id, next_item, ready_items, blocked_items, items)
+
+        return next_item  # type: ignore[no-any-return]
+
+    def _is_blocked(self, item: dict, all_items: dict) -> bool:
+        """Check if work item is blocked by dependencies
+
+        Args:
+            item: Work item to check
+            all_items: All work items
+
+        Returns:
+            bool: True if blocked
+        """
+        dependencies = item.get("dependencies", [])
+        if not dependencies:
+            return False
+
+        for dep_id in dependencies:
+            if dep_id not in all_items:
+                continue
+            if all_items[dep_id]["status"] != WorkItemStatus.COMPLETED.value:
+                return True
+
+        return False
+
+    def _display_next_item(
+        self,
+        next_id: str,
+        next_item: dict,
+        ready_items: list,
+        blocked_items: list,
+        all_items: dict,
+    ) -> None:
+        """Display the next recommended work item
+
+        Args:
+            next_id: ID of next item
+            next_item: Next item data
+            ready_items: List of ready items
+            blocked_items: List of blocked items
+            all_items: All work items
+        """
+        output.info("\nNext Recommended Work Item:")
+        output.info("=" * 80)
+        output.info("")
+
+        priority_emoji = {
+            Priority.CRITICAL.value: "🔴",
+            Priority.HIGH.value: "🟠",
+            Priority.MEDIUM.value: "🟡",
+            Priority.LOW.value: "🟢",
+        }
+
+        emoji = priority_emoji.get(next_item["priority"], "")
+        output.info(f"{emoji} {next_item['priority'].upper()}: {next_item['title']}")
+        output.info(f"ID: {next_id}")
+        output.info(f"Type: {next_item['type']}")
+        output.info(f"Priority: {next_item['priority']}")
+        output.info("Ready to start: Yes ✓")
+        output.info("")
+
+        # Dependencies
+        deps = next_item.get("dependencies", [])
+        if deps:
+            output.info("Dependencies: All satisfied")
+            for dep_id in deps:
+                output.info(f"  ✓ {dep_id} (completed)")
+        else:
+            output.info("Dependencies: None")
+        output.info("")
+
+        # Estimated effort
+        estimated = next_item.get("estimated_effort", "Unknown")
+        output.info(f"Estimated effort: {estimated}")
+        output.info("")
+
+        output.info("To start: /start")
+        output.info("")
+
+        # Show other items
+        if len(ready_items) > 1 or blocked_items:
+            output.info("Other items waiting:")
+            for work_id, item in ready_items[1:3]:  # Show next 2 ready items
+                emoji = priority_emoji.get(item["priority"], "")
+                output.info(f"  {emoji} {work_id} - Ready ({item['priority']} priority)")
+
+            for work_id, item, blocking in blocked_items[:2]:  # Show 2 blocked items
+                output.info(f"  🔴 {work_id} - Blocked by: {', '.join(blocking[:2])}")
+            output.info("")