monoco-toolkit 0.1.1__py3-none-any.whl → 0.2.8__py3-none-any.whl

monoco/features/issue/domain/lifecycle.py

@@ -0,0 +1,126 @@
+from typing import List, Optional, Callable
+from pydantic import BaseModel
+from ..models import IssueStatus, IssueStage, IssueSolution, current_time
+from .models import Issue
+
+class Transition(BaseModel):
+    name: str
+    from_status: Optional[IssueStatus] = None # None means any
+    from_stage: Optional[IssueStage] = None   # None means any
+    to_status: IssueStatus
+    to_stage: Optional[IssueStage] = None
+    required_solution: Optional[IssueSolution] = None
+    description: str = ""
+
+    def is_allowed(self, issue: Issue) -> bool:
+        if self.from_status and issue.status != self.from_status:
+            return False
+        if self.from_stage and issue.frontmatter.stage != self.from_stage:
+            return False
+        return True
+
+class TransitionService:
+    def __init__(self):
+        self.transitions: List[Transition] = [
+            # Open -> Backlog
+            Transition(
+                name="freeze",
+                from_status=IssueStatus.OPEN,
+                to_status=IssueStatus.BACKLOG,
+                to_stage=IssueStage.FREEZED,
+                description="Move open issue to backlog"
+            ),
+            # Backlog -> Open
+            Transition(
+                name="activate",
+                from_status=IssueStatus.BACKLOG,
+                to_status=IssueStatus.OPEN,
+                to_stage=IssueStage.DRAFT, # Reset to draft?
+                description="Restore issue from backlog"
+            ),
+            # Open (Draft) -> Open (Doing)
+            Transition(
+                name="start",
+                from_status=IssueStatus.OPEN,
+                from_stage=IssueStage.DRAFT,
+                to_status=IssueStatus.OPEN,
+                to_stage=IssueStage.DOING,
+                description="Start working on the issue"
+            ),
+            # Open (Doing) -> Open (Review)
+            Transition(
+                name="submit",
+                from_status=IssueStatus.OPEN,
+                from_stage=IssueStage.DOING,
+                to_status=IssueStatus.OPEN,
+                to_stage=IssueStage.REVIEW,
+                description="Submit for review"
+            ),
+             # Open (Review) -> Open (Doing) - reject
+            Transition(
+                name="reject",
+                from_status=IssueStatus.OPEN,
+                from_stage=IssueStage.REVIEW,
+                to_status=IssueStatus.OPEN,
+                to_stage=IssueStage.DOING,
+                description="Reject review and return to doing"
+            ),
+            # Open (Review) -> Closed (Implemented)
+            Transition(
+                name="accept",
+                from_status=IssueStatus.OPEN,
+                from_stage=IssueStage.REVIEW,
+                to_status=IssueStatus.CLOSED,
+                to_stage=IssueStage.DONE,
+                required_solution=IssueSolution.IMPLEMENTED,
+                description="Accept and close issue"
+            ),
+            # Direct Close (Cancel, Wontfix, Duplicate)
+            Transition(
+                name="cancel",
+                to_status=IssueStatus.CLOSED,
+                to_stage=IssueStage.DONE,
+                required_solution=IssueSolution.CANCELLED,
+                description="Cancel the issue"
+            ),
+             Transition(
+                name="wontfix",
+                to_status=IssueStatus.CLOSED,
+                to_stage=IssueStage.DONE,
+                required_solution=IssueSolution.WONTFIX,
+                description="Mark as wontfix"
+            ),
+        ]
+
+    def get_available_transitions(self, issue: Issue) -> List[Transition]:
+        return [t for t in self.transitions if t.is_allowed(issue)]
+
+    def apply_transition(self, issue: Issue, transition_name: str) -> Issue:
+        # Find transition
+        candidates = [t for t in self.transitions if t.name == transition_name]
+        valid_transition = None
+        for t in candidates:
+            if t.is_allowed(issue):
+                valid_transition = t
+                break
+        
+        if not valid_transition:
+            raise ValueError(f"Transition '{transition_name}' is not allowed for current state.")
+
+        # Apply changes
+        issue.frontmatter.status = valid_transition.to_status
+        if valid_transition.to_stage:
+            issue.frontmatter.stage = valid_transition.to_stage
+        if valid_transition.required_solution:
+            issue.frontmatter.solution = valid_transition.required_solution
+            
+        issue.frontmatter.updated_at = current_time()
+        
+        # Logic for closed_at, opened_at etc.
+        if valid_transition.to_status == IssueStatus.CLOSED and issue.frontmatter.closed_at is None:
+            issue.frontmatter.closed_at = current_time()
+            
+        if valid_transition.to_status == IssueStatus.OPEN and issue.frontmatter.opened_at is None:
+             issue.frontmatter.opened_at = current_time()
+            
+        return issue

monoco/features/issue/domain/models.py

@@ -0,0 +1,170 @@
+from typing import List, Optional, Any, Dict
+from pydantic import BaseModel, Field, model_validator
+from datetime import datetime
+from ..models import IssueType, IssueStatus, IssueStage, IssueSolution, IssueIsolation, IssueID, current_time
+from monoco.core.lsp import Range, Position
+
+class Span(BaseModel):
+    """
+    Represents a fine-grained location inside a ContentBlock.
+    """
+    type: str  # 'wikilink', 'issue_id', 'checkbox', 'yaml_key', 'plain_text'
+    range: Range
+    content: str
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+class ContentBlock(BaseModel):
+    """
+    Represents a block of content in the markdown body.
+    """
+    type: str  # e.g., 'heading', 'task_list', 'paragraph', 'empty'
+    content: str
+    line_start: int
+    line_end: int
+    spans: List[Span] = Field(default_factory=list)
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+    def to_string(self) -> str:
+        return self.content
+
+from enum import Enum
+
+class TaskState(str, Enum):
+    TODO = " "
+    DONE = "x"
+    DOING = "-"
+    CANCELLED = "+"
+
+class TaskItem(ContentBlock):
+    type: str = "task_item" # override type
+    state: TaskState = TaskState.TODO
+    level: int = 0
+    parent_index: Optional[int] = None
+    
+    @property
+    def is_completed(self) -> bool:
+        return self.state in [TaskState.DONE, TaskState.CANCELLED]
+
+class IssueBody(BaseModel):
+    """
+    Represents the parsed body of the issue.
+    """
+    blocks: List[ContentBlock] = Field(default_factory=list)
+    
+    def to_markdown(self) -> str:
+        return "\n".join(b.to_string() for b in self.blocks)
+
+    @property
+    def raw(self) -> str:
+        return self.to_markdown()
+
+    @property
+    def tasks(self) -> List[TaskItem]:
+        return [b for b in self.blocks if isinstance(b, TaskItem) or (isinstance(b, ContentBlock) and b.type == 'task_item')]
+    
+    @property
+    def progress(self) -> str:
+        tasks = self.tasks
+        if not tasks:
+            return "0/0"
+        completed = len([t for t in tasks if isinstance(t, TaskItem) and t.is_completed])
+        return f"{completed}/{len(tasks)}"
+
+class IssueFrontmatter(BaseModel):
+    """
+    Represents the YAML frontmatter of the issue.
+    Contains metadata and validation logic.
+    """
+    id: str
+    uid: Optional[str] = None
+    type: IssueType
+    status: IssueStatus = IssueStatus.OPEN
+    stage: Optional[IssueStage] = None
+    title: str
+    created_at: datetime = Field(default_factory=current_time)
+    opened_at: Optional[datetime] = None
+    updated_at: datetime = Field(default_factory=current_time)
+    closed_at: Optional[datetime] = None
+    parent: Optional[str] = None
+    dependencies: List[str] = Field(default_factory=list)
+    related: List[str] = Field(default_factory=list)
+    tags: List[str] = Field(default_factory=list)
+    solution: Optional[IssueSolution] = None
+    isolation: Optional[IssueIsolation] = None
+    
+    model_config = {"extra": "allow"}
+
+    @model_validator(mode='before')
+    @classmethod
+    def normalize_fields(cls, v: Any) -> Any:
+        # Reusing normalization logic from original model or keeping it clean here
+        if isinstance(v, dict):
+            if "type" in v and isinstance(v["type"], str):
+                v["type"] = v["type"].lower()
+            if "status" in v and isinstance(v["status"], str):
+                v["status"] = v["status"].lower()
+        return v
+
+class Issue(BaseModel):
+    """
+    The Aggregate Root for an Issue in the Domain Layer.
+    """
+    path: Optional[str] = None
+    frontmatter: IssueFrontmatter
+    body: IssueBody
+
+    @property
+    def id(self) -> str:
+        return self.frontmatter.id
+    
+    @property
+    def status(self) -> IssueStatus:
+        return self.frontmatter.status
+        
+    def to_file_content(self) -> str:
+        """
+        Reconstruct the full file content.
+        """
+        import yaml
+        
+        # Dump frontmatter
+        # Dump frontmatter with explicit field handling
+        # We want to keep certain fields even if empty to serve as prompts
+        data = self.frontmatter.model_dump(mode='json')
+        
+        # Explicit ordering and key retention
+        # We construct a new dict to control order and presence
+        ordered_dump = {}
+        
+        # 1. Identity
+        ordered_dump['id'] = data['id']
+        if data.get('uid'): ordered_dump['uid'] = data['uid']
+        
+        # 2. Classifier
+        ordered_dump['type'] = data['type']
+        ordered_dump['status'] = data['status']
+        if data.get('stage'): ordered_dump['stage'] = data['stage']
+        
+        # 3. Content
+        ordered_dump['title'] = data['title']
+        
+        # 4. Dates (Always keep created/updated, others if exist)
+        ordered_dump['created_at'] = data['created_at']
+        if data.get('opened_at'): ordered_dump['opened_at'] = data['opened_at']
+        ordered_dump['updated_at'] = data['updated_at']
+        if data.get('closed_at'): ordered_dump['closed_at'] = data['closed_at']
+        
+        # 5. Graph (Always include to prompt usage)
+        ordered_dump['parent'] = data.get('parent') # Allow null
+        ordered_dump['dependencies'] = data.get('dependencies', [])
+        ordered_dump['related'] = data.get('related', [])
+        ordered_dump['tags'] = data.get('tags', [])
+        
+        # 6. Lifecycle (Optional)
+        if data.get('solution'): ordered_dump['solution'] = data['solution']
+        if data.get('isolation'): ordered_dump['isolation'] = data['isolation']
+
+        fm_str = yaml.dump(ordered_dump, sort_keys=False, allow_unicode=True).strip()
+        body_str = self.body.to_markdown()
+        
+        return f"---\n{fm_str}\n---\n\n{body_str}"

monoco/features/issue/domain/parser.py

@@ -0,0 +1,223 @@
+import yaml
+import re
+from typing import List, Optional, Tuple, Any
+from .models import Issue, IssueFrontmatter, IssueBody, ContentBlock, Span
+from monoco.core.lsp import Range, Position
+
+class MarkdownParser:
+    """
+    Parses markdown content into Domain Models.
+    """
+
+    # Regex for standard Issue IDs and cross-project IDs
+    ISSUE_ID_PATTERN = r"\b((?:[a-zA-Z0-9_]+::)?(?:EPIC|FEAT|CHORE|FIX)-\d{4})\b"
+    # Regex for Wikilinks [[Project::IssueID]] or [[IssueID]]
+    WIKILINK_PATTERN = r"\[\[((?:[a-zA-Z0-9_]+::)?(?:EPIC|FEAT|CHORE|FIX)-\d{4})\]\]"
+
+    @staticmethod
+    def parse(content: str, path: Optional[str] = None) -> Issue:
+        lines = content.splitlines()
+        
+        # 1. Parse Frontmatter
+        frontmatter_dict, body_start_line = MarkdownParser._extract_frontmatter(lines)
+        
+        # 2. Create Frontmatter Object
+        # Handle cases where frontmatter might be empty or invalid
+        if not frontmatter_dict:
+            # Fallback or error? For now, assume valid issues have frontmatter.
+            # But during creation/drafting it might be partial.
+            # We'll assume the input content *should* be a valid issue file.
+            pass
+
+        frontmatter = IssueFrontmatter(**frontmatter_dict)
+
+        # 3. Parse Body
+        body_lines = lines[body_start_line:]
+        # Adjust line numbers relative to the original file
+        blocks = MarkdownParser._parse_blocks(body_lines, start_line_offset=body_start_line)
+        
+        body = IssueBody(blocks=blocks)
+
+        return Issue(path=path, frontmatter=frontmatter, body=body)
+
+    @staticmethod
+    def _extract_frontmatter(lines: List[str]) -> Tuple[dict, int]:
+        """
+        Extracts YAML frontmatter. Returns (dict, body_start_line_index).
+        """
+        if not lines or lines[0].strip() != "---":
+            return {}, 0
+        
+        fm_lines = []
+        i = 1
+        while i < len(lines):
+            line = lines[i]
+            if line.strip() == "---":
+                return yaml.safe_load("\n".join(fm_lines)), i + 1
+            fm_lines.append(line)
+            i += 1
+            
+        return {}, 0 # malformed
+
+    @staticmethod
+    def _parse_blocks(lines: List[str], start_line_offset: int) -> List[ContentBlock]:
+        blocks = []
+        current_block_lines = []
+        current_block_type = "paragraph"
+        current_start_line = start_line_offset
+        
+        def flush_block():
+            nonlocal current_block_lines, current_start_line
+            if current_block_lines:
+                content = "\n".join(current_block_lines)
+                block = ContentBlock(
+                    type=current_block_type,
+                    content=content,
+                    line_start=current_start_line,
+                    line_end=current_start_line + len(current_block_lines)
+                )
+                block.spans = MarkdownParser._parse_spans(current_block_lines, current_start_line)
+                blocks.append(block)
+                current_block_lines = []
+
+        for i, line in enumerate(lines):
+            abs_line_idx = start_line_offset + i
+            
+            # Simple heuristic for block detection
+            # 1. Heading
+            if re.match(r"^#{1,6}\s", line):
+                flush_block()
+                
+                # Add heading as its own block
+                block = ContentBlock(
+                    type="heading",
+                    content=line,
+                    line_start=abs_line_idx,
+                    line_end=abs_line_idx + 1
+                )
+                block.spans = MarkdownParser._parse_spans([line], abs_line_idx)
+                blocks.append(block)
+                current_start_line = abs_line_idx + 1
+                current_block_type = "paragraph" # reset
+                continue
+
+            # 2. Task List Item
+            # Regex to capture indent, state char
+            task_match = re.match(r"^(\s*)-\s*\[([ xX\-\+~/])\]", line)
+            if task_match:
+                flush_block()
+
+                indent_str = task_match.group(1)
+                state_char = task_match.group(2).lower()
+                
+                # Calculate level (assuming 2 spaces per level)
+                level = len(indent_str) // 2 
+                
+                # Determine state
+                from .models import TaskState, TaskItem
+                state_map = {
+                    " ": TaskState.TODO,
+                    "x": TaskState.DONE,
+                    "-": TaskState.DOING,  # Legacy
+                    "/": TaskState.DOING,  # New Standard
+                    "+": TaskState.CANCELLED, # Legacy
+                    "~": TaskState.CANCELLED  # New Standard
+                }
+                
+                # Fallback for 'X' -> 'x'
+                if state_char not in state_map and state_char == 'x':
+                    state_char = 'x'
+
+                block = TaskItem(
+                    content=line,
+                    line_start=abs_line_idx,
+                    line_end=abs_line_idx + 1,
+                    state=state_map.get(state_char, TaskState.TODO),
+                    level=level,
+                    metadata={"checked": state_char in ['x', '+']}
+                )
+                block.spans = MarkdownParser._parse_spans([line], abs_line_idx)
+                blocks.append(block)
+                current_start_line = abs_line_idx + 1
+                current_block_type = "paragraph"
+                continue
+
+            # 3. Empty lines (separators)
+            if not line.strip():
+                 flush_block()
+                 
+                 blocks.append(ContentBlock(
+                     type="empty",
+                     content="",
+                     line_start=abs_line_idx,
+                     line_end=abs_line_idx + 1
+                 ))
+                 current_start_line = abs_line_idx + 1
+                 current_block_type = "paragraph"
+                 continue
+
+            # Default: accumulate lines into paragraph
+            if not current_block_lines:
+                current_start_line = abs_line_idx
+            
+            current_block_lines.append(line)
+            
+        # Flush remaining
+        flush_block()
+
+        return blocks
+
+    @staticmethod
+    def _parse_spans(lines: List[str], line_offset: int) -> List[Span]:
+        """
+        Parses a list of lines into Spans.
+        """
+        spans = []
+        for i, line in enumerate(lines):
+            abs_line_idx = line_offset + i
+            
+            # 1. Parse Checkboxes (only at start of line)
+            checkbox_match = re.match(r"^(\s*-\s*\[)([ xX\-\+~/])(\])", line)
+            if checkbox_match:
+                start_char = len(checkbox_match.group(1))
+                end_char = start_char + 1
+                spans.append(Span(
+                    type="checkbox",
+                    range=Range(
+                        start=Position(line=abs_line_idx, character=start_char),
+                        end=Position(line=abs_line_idx, character=end_char)
+                    ),
+                    content=checkbox_match.group(2),
+                    metadata={"state": checkbox_match.group(2)}
+                ))
+
+            # 2. Parse Wikilinks
+            for match in re.finditer(MarkdownParser.WIKILINK_PATTERN, line):
+                spans.append(Span(
+                    type="wikilink",
+                    range=Range(
+                        start=Position(line=abs_line_idx, character=match.start()),
+                        end=Position(line=abs_line_idx, character=match.end())
+                    ),
+                    content=match.group(0),
+                    metadata={"issue_id": match.group(1)}
+                ))
+
+            # 3. Parse Raw Issue IDs (not inside wikilinks)
+            # We use a simple exclusion logic: if a match is inside a wikilink, skip it.
+            wikilink_ranges = [(s.range.start.character, s.range.end.character) for s in spans if s.type == "wikilink" and s.range.start.line == abs_line_idx]
+            
+            for match in re.finditer(MarkdownParser.ISSUE_ID_PATTERN, line):
+                is_inside = any(r[0] <= match.start() and match.end() <= r[1] for r in wikilink_ranges)
+                if not is_inside:
+                    spans.append(Span(
+                        type="issue_id",
+                        range=Range(
+                            start=Position(line=abs_line_idx, character=match.start()),
+                            end=Position(line=abs_line_idx, character=match.end())
+                        ),
+                        content=match.group(0),
+                        metadata={"issue_id": match.group(1)}
+                    ))
+        
+        return spans

monoco/features/issue/domain/workspace.py

@@ -0,0 +1,104 @@
+import re
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+from pydantic import BaseModel
+from .parser import MarkdownParser
+from .models import Issue
+from monoco.core.config import get_config, MonocoConfig
+from monoco.core.lsp import Location, Range, Position
+
+class IssueLocation(BaseModel):
+    project_id: str
+    file_path: str
+    issue_id: str
+
+class WorkspaceSymbolIndex:
+    """
+    Maintains a global index of all issues in the Monoco Workspace.
+    Allows resolving Issue IDs (local or namespaced) to file locations.
+    """
+    
+    def __init__(self, root_path: Path):
+        self.root_path = root_path
+        self.index: Dict[str, IssueLocation] = {}  # Map<FullID, Location>
+        self.local_map: Dict[str, str] = {} # Map<LocalID, FullID> for current context project
+        self._is_indexed = False
+
+    def build_index(self, recursive: bool = True):
+        """
+        Scans the workspace and subprojects to build the index.
+        """
+        self.index.clear()
+        
+        # 1. Index local project
+        project_name = "local"
+        conf = get_config(str(self.root_path))
+        if conf and conf.project and conf.project.name:
+            project_name = conf.project.name.lower()
+            
+        self._index_project(self.root_path, project_name)
+        
+        # 2. Index workspace members
+        if recursive:
+            try:
+                for member_name, rel_path in conf.project.members.items():
+                    member_root = (self.root_path / rel_path).resolve()
+                    if member_root.exists():
+                        self._index_project(member_root, member_name.lower())
+            except Exception:
+                pass
+                
+        self._is_indexed = True
+
+    def _index_project(self, project_root: Path, project_name: str):
+        issues_dir = project_root / "Issues"
+        if not issues_dir.exists():
+            return
+
+        # Scan Epics, Features, Chores, Fixes
+        for subdir in ["Epics", "Features", "Chores", "Fixes"]:
+            d = issues_dir / subdir
+            if d.exists():
+                for f in d.rglob("*.md"):
+                    # Filename format: {ID}-{slug}.md
+                    # Regex: EPIC-0016-title.md -> EPIC-0016
+                    match = re.match(r"^((?:EPIC|FEAT|CHORE|FIX)-\d{4})", f.name)
+                    if match:
+                        issue_id = match.group(1)
+                        full_id = f"{project_name}::{issue_id}"
+                        loc = IssueLocation(
+                            project_id=project_name,
+                            file_path=str(f.absolute()),
+                            issue_id=issue_id
+                        )
+                        self.index[full_id] = loc
+                        self.index[issue_id] = loc # Alias for local lookup
+
+    def resolve(self, issue_id: str, context_project: Optional[str] = None) -> Optional[IssueLocation]:
+        """
+        Resolves an issue ID to its location.
+        Supports 'Project::ID' and 'ID'.
+        """
+        if not self._is_indexed:
+            self.build_index()
+
+        # Normalize lookup ID
+        if "::" in issue_id:
+            proj, lid = issue_id.split("::", 1)
+            issue_id = f"{proj.lower()}::{lid.upper()}"
+        else:
+            issue_id = issue_id.upper()
+            if context_project:
+                context_project = context_project.lower()
+
+        # 1. Try exact match
+        if issue_id in self.index:
+            return self.index[issue_id]
+            
+        # 2. Try contextual resolution if it's a local ID
+        if "::" not in issue_id and context_project:
+            full_id = f"{context_project}::{issue_id}"
+            if full_id in self.index:
+                return self.index[full_id]
+                
+        return None

monoco/features/issue/engine/__init__.py

@@ -0,0 +1,22 @@
+from typing import Optional
+from .models import Transition
+
+from .machine import StateMachine
+from .config import DEFAULT_ISSUE_CONFIG
+from monoco.core.config import get_config
+
+def get_engine(project_root: Optional[str] = None) -> StateMachine:
+    # 1. Load Core Config (merges workspace & project yamls)
+    core_config = get_config(project_root)
+    
+    # 2. Start with Defaults
+    # Use model_copy to avoid mutating the global default instance
+    final_config = DEFAULT_ISSUE_CONFIG.model_copy(deep=True)
+    
+    # 3. Merge User Overrides
+    if core_config.issue:
+        # core_config.issue is already an IssueSchemaConfig (parse/validated by Pydantic)
+        # We just need to merge it.
+        final_config.merge(core_config.issue)
+
+    return StateMachine(final_config)