workforge 2.4.1__py3-none-any.whl

workforge/config.py

@@ -0,0 +1,47 @@
+from pathlib import Path
+from typing import Any
+
+import yaml
+from dotenv import dotenv_values
+from pydantic import BaseModel, Field
+
+
+class WorkspaceDefaults(BaseModel):
+    source: str = "manual"
+    namespace: str = "default"
+    dry_run: bool = True
+
+
+class WorkspaceConfig(BaseModel):
+    name: str
+    default_provider: str = "trello"
+    providers: dict[str, dict[str, Any]] = Field(default_factory=dict)
+    defaults: WorkspaceDefaults = Field(default_factory=WorkspaceDefaults)
+
+
+class WorkspaceRuntime(BaseModel):
+    path: Path
+    config: WorkspaceConfig
+    env: dict[str, str] = Field(default_factory=dict)
+
+
+def load_workspace_config(workspace_path: Path) -> WorkspaceConfig:
+    return load_workspace(workspace_path).config
+
+
+def load_workspace(workspace_path: Path) -> WorkspaceRuntime:
+    config_path = workspace_path / "workforge.yaml"
+    if not config_path.exists():
+        raise FileNotFoundError(f"Workspace config not found: {config_path}")
+
+    env_path = workspace_path / ".env"
+    env: dict[str, str] = {}
+    if env_path.exists():
+        env = {key: value for key, value in dotenv_values(env_path).items() if value is not None}
+
+    raw_config = yaml.safe_load(config_path.read_text()) or {}
+    return WorkspaceRuntime(
+        path=workspace_path,
+        config=WorkspaceConfig.model_validate(raw_config),
+        env=env,
+    )

workforge/core/__init__.py

@@ -0,0 +1 @@
+"""Core WorkForge behavior."""

workforge/core/parser.py

@@ -0,0 +1,97 @@
+from collections.abc import Iterable
+
+from workforge.config import WorkspaceConfig
+from workforge.models import Priority, Requirement, WorkTask
+
+
+META_PREFIXES = {
+    "source": "source",
+    "priority": "priority",
+    "labels": "labels",
+    "namespace": "namespace",
+    "milestone": "milestone",
+}
+
+
+def parse_markdown_requirements(content: str, config: WorkspaceConfig) -> list[Requirement]:
+    sections = _split_h2_sections(content)
+    return [_parse_section(title, lines, config) for title, lines in sections]
+
+
+def _split_h2_sections(content: str) -> list[tuple[str, list[str]]]:
+    sections: list[tuple[str, list[str]]] = []
+    current_title: str | None = None
+    current_lines: list[str] = []
+
+    for line in content.splitlines():
+        if line.startswith("## "):
+            if current_title:
+                sections.append((current_title, current_lines))
+            current_title = line.removeprefix("## ").strip()
+            current_lines = []
+        elif current_title:
+            current_lines.append(line)
+
+    if current_title:
+        sections.append((current_title, current_lines))
+
+    return sections
+
+
+def _parse_section(title: str, lines: Iterable[str], config: WorkspaceConfig) -> Requirement:
+    metadata: dict[str, str] = {}
+    description_lines: list[str] = []
+    tasks: list[WorkTask] = []
+
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            continue
+
+        key, value = _parse_metadata_line(stripped)
+        if key:
+            metadata[key] = value
+            continue
+
+        if stripped.startswith("- "):
+            tasks.append(WorkTask(title=stripped.removeprefix("- ").strip()))
+            continue
+
+        description_lines.append(stripped)
+
+    labels = _split_csv(metadata.get("labels", ""))
+    priority = metadata.get("priority", "medium")
+
+    return Requirement(
+        title=title,
+        description="\n".join(description_lines),
+        source=metadata.get("source", config.defaults.source),
+        namespace=metadata.get("namespace", config.defaults.namespace),
+        priority=_normalize_priority(priority),
+        milestone=metadata.get("milestone"),
+        labels=labels,
+        tasks=tasks,
+    )
+
+
+def _parse_metadata_line(line: str) -> tuple[str | None, str]:
+    if ":" not in line:
+        return None, ""
+
+    raw_key, raw_value = line.split(":", 1)
+    key = raw_key.strip().lower()
+    if key not in META_PREFIXES:
+        return None, ""
+
+    return META_PREFIXES[key], raw_value.strip()
+
+
+def _split_csv(value: str) -> list[str]:
+    return [part.strip() for part in value.split(",") if part.strip()]
+
+
+def _normalize_priority(value: str) -> Priority:
+    normalized = value.strip().lower()
+    if normalized in {"low", "medium", "high", "urgent"}:
+        return normalized  # type: ignore[return-value]
+    return "medium"

workforge/models.py

@@ -0,0 +1,54 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+Priority = Literal["low", "medium", "high", "urgent"]
+
+
+class WorkTask(BaseModel):
+    title: str
+    done: bool = False
+
+
+class Requirement(BaseModel):
+    title: str
+    description: str = ""
+    source: str = "manual"
+    namespace: str = "default"
+    priority: Priority = "medium"
+    milestone: str | None = None
+    labels: list[str] = Field(default_factory=list)
+    tasks: list[WorkTask] = Field(default_factory=list)
+
+
+class CreatedItem(BaseModel):
+    provider: str
+    id: str
+    url: str | None = None
+    title: str
+
+
+class TaskStatus(BaseModel):
+    id: str | None = None
+    title: str
+    done: bool = False
+
+
+class ItemStatus(BaseModel):
+    provider: str
+    id: str
+    url: str | None = None
+    title: str
+    closed: bool = False
+    tasks: list[TaskStatus] = Field(default_factory=list)
+
+    @property
+    def completed_tasks(self) -> int:
+        return sum(1 for task in self.tasks if task.done)
+
+
+class ProviderCheck(BaseModel):
+    provider: str
+    ok: bool
+    message: str

workforge/providers/__init__.py

@@ -0,0 +1 @@
+"""Planning provider adapters."""

workforge/providers/base.py

@@ -0,0 +1,48 @@
+from abc import ABC, abstractmethod
+
+from workforge.models import CreatedItem, ItemStatus, ProviderCheck, Requirement
+
+
+class PlanningProvider(ABC):
+    name: str
+
+    @abstractmethod
+    async def check(self) -> ProviderCheck:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def create_requirement(self, requirement: Requirement) -> CreatedItem:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def update_requirement_tasks(self, item: CreatedItem, requirement: Requirement) -> ItemStatus:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_item_status(self, item: CreatedItem) -> ItemStatus:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def complete_task(self, item: CreatedItem, task_ref: str) -> ItemStatus:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def comment_item(self, item: CreatedItem, text: str) -> ItemStatus:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def move_item(self, item: CreatedItem, status_ref: str) -> ItemStatus:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def claim_item(self, item: CreatedItem, assignee_ref: str = "@me") -> ItemStatus:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def discover_items(
+        self,
+        label_ref: str | None = None,
+        assignee_ref: str | None = None,
+        status_ref: str | None = None,
+    ) -> list[CreatedItem]:
+        raise NotImplementedError