monoco-toolkit 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

monoco/features/issue/engine/machine.py

@@ -0,0 +1,185 @@
+from typing import List, Optional, Dict
+from monoco.core.config import IssueSchemaConfig, TransitionConfig
+from ..models import IssueStatus, IssueStage, IssueMetadata, IssueSolution, IssueType
+
+class StateMachine:
+    def __init__(self, config: IssueSchemaConfig):
+        self.issue_config = config
+        self.transitions = config.workflows or []
+
+    def get_type_config(self, type_name: str):
+        if not self.issue_config.types:
+            return None
+        for t in self.issue_config.types:
+            if t.name == type_name:
+                return t
+        return None
+
+    def get_prefix_map(self) -> Dict[str, str]:
+        if not self.issue_config.types:
+            return {}
+        return {t.name: t.prefix for t in self.issue_config.types}
+
+    def get_folder_map(self) -> Dict[str, str]:
+        if not self.issue_config.types:
+            return {}
+        return {t.name: t.folder for t in self.issue_config.types}
+
+    def get_all_types(self) -> List[str]:
+        if not self.issue_config.types:
+            return []
+        return [t.name for t in self.issue_config.types]
+
+    def can_transition(self, current_status: str, current_stage: Optional[str], 
+                       target_status: str, target_stage: Optional[str]) -> bool:
+        """Check if a transition path exists."""
+        for t in self.transitions:
+            if t.from_status and t.from_status != current_status:
+                continue
+            if t.from_stage and t.from_stage != current_stage:
+                continue
+            
+            if t.to_status == target_status:
+                if target_stage is None or t.to_stage == target_stage:
+                    return True
+        return False
+
+    def get_available_transitions(self, meta: IssueMetadata) -> List[TransitionConfig]:
+        """Get all transitions allowed from the current state of the issue."""
+        allowed = []
+        for t in self.transitions:
+            # Universal actions (no from_status/stage) are always allowed
+            if t.from_status is None and t.from_stage is None:
+                allowed.append(t)
+                continue
+
+            # Match status
+            if t.from_status and t.from_status != meta.status:
+                continue
+            
+            # Match stage
+            if t.from_stage and t.from_stage != meta.stage:
+                continue
+            
+            # Special case for 'Cancel': don't show if already DONE or CLOSED
+            if t.name == "cancel" and meta.stage == "done":
+                continue
+
+            allowed.append(t)
+        return allowed
+
+    def find_transition(self, from_status: str, from_stage: Optional[str],
+                        to_status: str, to_stage: Optional[str],
+                        solution: Optional[str] = None) -> Optional[TransitionConfig]:
+        """Find a specific transition rule."""
+        candidates = []
+        for t in self.transitions:
+            # Skip non-transitions (agent actions with same status/stage)
+            if t.from_status is None and t.from_stage is None:
+                continue
+
+            if t.from_status and t.from_status != from_status:
+                continue
+            if t.from_stage and t.from_stage != from_stage:
+                continue
+            
+            # Check if this transition matches the target
+            if t.to_status == to_status:
+                if to_stage is None or t.to_stage == to_stage:
+                    candidates.append(t)
+        
+        if not candidates:
+            return None
+        
+        # If we have a solution, find the transition that requires it
+        if solution:
+            for t in candidates:
+                if t.required_solution == solution:
+                    return t
+            # If solution provided but none of the transitions match it,
+            # we should return None (unless there is a transition with NO required_solution)
+            for t in candidates:
+                if t.required_solution is None:
+                    return t
+            return None
+        
+        # Otherwise return the first one that has NO required_solution
+        for t in candidates:
+            if t.required_solution is None:
+                return t
+        
+        return candidates[0]
+
+    def validate_transition(self, from_status: str, from_stage: Optional[str],
+                            to_status: str, to_stage: Optional[str],
+                            solution: Optional[str] = None) -> None:
+        """
+        Validate if a transition is allowed. Raises ValueError if not.
+        """
+        if from_status == to_status and from_stage == to_stage:
+            return # No change is always allowed (unless we want to enforce specific updates)
+
+        transition = self.find_transition(from_status, from_stage, to_status, to_stage, solution)
+        
+        if not transition:
+            raise ValueError(f"Lifecycle Policy: Transition from {from_status}({from_stage if from_stage else 'None'}) "
+                             f"to {to_status}({to_stage if to_stage else 'None'}) is not defined.")
+
+        if transition.required_solution and solution != transition.required_solution:
+             raise ValueError(f"Lifecycle Policy: Transition '{transition.label}' requires solution '{transition.required_solution}'.")
+
+    def enforce_policy(self, meta: IssueMetadata) -> None:
+        """
+        Apply consistency rules to IssueMetadata.
+        """
+        from ..models import current_time
+        
+        if meta.status == "backlog":
+            meta.stage = "freezed"
+        
+        elif meta.status == "closed":
+            if meta.stage != "done":
+                meta.stage = "done"
+            if not meta.closed_at:
+                meta.closed_at = current_time()
+        
+        elif meta.status == "open":
+            if meta.stage is None:
+                meta.stage = "draft"
+
+    def validate_transition(self, from_status: str, from_stage: Optional[str],
+                            to_status: str, to_stage: Optional[str],
+                            solution: Optional[str] = None) -> None:
+        """
+        Validate if a transition is allowed. Raises ValueError if not.
+        """
+        if from_status == to_status and from_stage == to_stage:
+            return # No change is always allowed (unless we want to enforce specific updates)
+
+        transition = self.find_transition(from_status, from_stage, to_status, to_stage, solution)
+        
+        if not transition:
+            raise ValueError(f"Lifecycle Policy: Transition from {from_status}({from_stage if from_stage else 'None'}) "
+                             f"to {to_status}({to_stage if to_stage else 'None'}) is not defined.")
+
+        if transition.required_solution and solution != transition.required_solution:
+             raise ValueError(f"Lifecycle Policy: Transition '{transition.label}' requires solution '{transition.required_solution}'.")
+
+    def enforce_policy(self, meta: IssueMetadata) -> None:
+        """
+        Apply consistency rules to IssueMetadata.
+        """
+        from ..models import current_time
+        
+        if meta.status == "backlog":
+            meta.stage = "freezed"
+        
+        elif meta.status == "closed":
+            if meta.stage != "done":
+                meta.stage = "done"
+            if not meta.closed_at:
+                meta.closed_at = current_time()
+        
+        elif meta.status == "open":
+            if meta.stage is None:
+                meta.stage = "draft"

monoco/features/issue/engine/models.py

@@ -0,0 +1,18 @@
+from typing import List, Optional, Any
+from pydantic import BaseModel
+
+class Transition(BaseModel):
+    name: str
+    label: str
+    icon: Optional[str] = None
+    from_status: Optional[str] = None  # None means any
+    from_stage: Optional[str] = None    # None means any
+    to_status: str
+    to_stage: Optional[str] = None
+    required_solution: Optional[str] = None
+    description: str = ""
+    command_template: Optional[str] = None
+
+class StateMachineConfig(BaseModel):
+    transitions: List[Transition]
+    # We can add more config like default stages for statuses etc.

monoco/features/issue/linter.py

@@ -38,27 +38,48 @@ def check_integrity(issues_root: Path, recursive: bool = False) -> List[Diagnost
                     meta = core.parse_issue(f)
                     if meta:
                         local_id = meta.id
-                        full_id = f"{project_name}::{local_id}" if project_name != "local" else local_id
+                        full_id = f"{project_name}::{local_id}"
                         
                         all_issue_ids.add(local_id)
-                        if project_name != "local":
-                            all_issue_ids.add(full_id)
+                        all_issue_ids.add(full_id)
                         
                         project_issues.append((f, meta))
         return project_issues
 
-    all_issues.extend(collect_project_issues(issues_root, "local"))
+    from monoco.core.config import get_config
+    conf = get_config(str(issues_root.parent))
+    
+    # Identify local project name
+    local_project_name = "local"
+    if conf and conf.project and conf.project.name:
+        local_project_name = conf.project.name.lower()
+
+    # Find Topmost Workspace Root
+    workspace_root = issues_root.parent
+    for parent in [workspace_root] + list(workspace_root.parents):
+        if (parent / ".monoco" / "workspace.yaml").exists() or (parent / ".monoco" / "project.yaml").exists():
+            workspace_root = parent
+            
+    # Collect from local issues_root
+    all_issues.extend(collect_project_issues(issues_root, local_project_name))
     
     if recursive:
         try:
-            from monoco.core.config import get_config
-            project_root = issues_root.parent
-            conf = get_config(str(project_root))
-            for member_name, rel_path in conf.project.members.items():
-                member_root = (project_root / rel_path).resolve()
+            # Re-read config from workspace root to get all members
+            ws_conf = get_config(str(workspace_root))
+            
+            # Index Root project if different from current
+            if workspace_root != issues_root.parent:
+                root_issues_dir = workspace_root / "Issues"
+                if root_issues_dir.exists():
+                    all_issues.extend(collect_project_issues(root_issues_dir, ws_conf.project.name.lower()))
+
+            # Index all members
+            for member_name, rel_path in ws_conf.project.members.items():
+                member_root = (workspace_root / rel_path).resolve()
                 member_issues_dir = member_root / "Issues"
-                if member_issues_dir.exists():
-                    collect_project_issues(member_issues_dir, member_name)
+                if member_issues_dir.exists() and member_issues_dir != issues_root:
+                    all_issues.extend(collect_project_issues(member_issues_dir, member_name.lower()))
         except Exception:
             pass
 

monoco/features/issue/lsp/__init__.py

@@ -0,0 +1,3 @@
+from .definition import DefinitionProvider
+
+__all__ = ["DefinitionProvider"]

monoco/features/issue/lsp/definition.py

@@ -0,0 +1,72 @@
+from pathlib import Path
+from typing import Optional, List
+from monoco.core.lsp import Location, Position, Range
+from ..domain.parser import MarkdownParser
+from ..domain.workspace import WorkspaceSymbolIndex, IssueLocation
+
+class DefinitionProvider:
+    def __init__(self, workspace_root: Path):
+        self.workspace_root = workspace_root
+        self.index = WorkspaceSymbolIndex(workspace_root)
+        # Lazy indexing handled by the index class itself
+
+    def provide_definition(self, file_path: Path, position: Position) -> List[Location]:
+        """
+        Resolve definition at the given position in the file.
+        """
+        if not file_path.exists():
+            return []
+
+        content = file_path.read_text()
+        
+        # 1. Parse the document to find spans
+        # We only need to find the span at the specific line
+        issue = MarkdownParser.parse(content, path=str(file_path))
+        
+        target_span = None
+        for block in issue.body.blocks:
+            # Check if position is within block
+             # Note: block.line_start is inclusive, line_end is exclusive for content
+            if block.line_start <= position.line < block.line_end:
+                 for span in block.spans:
+                     if span.range.start.line == position.line:
+                         # Check character range
+                         if span.range.start.character <= position.character <= span.range.end.character:
+                             target_span = span
+                             break
+            if target_span:
+                break
+        
+        if not target_span:
+            return []
+
+        # 2. Resolve based on span type
+        if target_span.type in ["wikilink", "issue_id"]:
+            issue_id = target_span.metadata.get("issue_id")
+            if issue_id:
+                # Resolve using Workspace Index
+                location = self.index.resolve(issue_id, context_project=self._get_context_project(file_path))
+                if location:
+                    return [
+                        Location(
+                            uri=f"file://{location.file_path}",
+                            range=Range(
+                                start=Position(line=0, character=0),
+                                end=Position(line=0, character=0)
+                            )
+                        )
+                    ]
+        
+        return []
+
+    def _get_context_project(self, file_path: Path) -> Optional[str]:
+        # Simple heuristic: look for parent directory name if it's a known project structure?
+        # Or rely on configuration. 
+        # For now, let's assume the index handles context if passed, or we pass None.
+        # Actually resolving context project from file path is tricky without config loaded for that specific root.
+        # Let's try to deduce from path relative to workspace root.
+        try:
+             rel = file_path.relative_to(self.workspace_root)
+             return rel.parts[0] # First dir is likely project name in a workspace
+        except ValueError:
+             return "local"

monoco/features/issue/models.py

@@ -78,16 +78,16 @@ class IsolationType(str, Enum):
     WORKTREE = "worktree"
 
 class IssueIsolation(BaseModel):
-    type: IsolationType
+    type: str
     ref: str  # Git branch name
     path: Optional[str] = None  # Worktree path (relative to repo root or absolute)
     created_at: datetime = Field(default_factory=current_time)
 
 class IssueAction(BaseModel):
     label: str
-    target_status: Optional[IssueStatus] = None
-    target_stage: Optional[IssueStage] = None
-    target_solution: Optional[IssueSolution] = None
+    target_status: Optional[str] = None
+    target_stage: Optional[str] = None
+    target_solution: Optional[str] = None
     icon: Optional[str] = None
     
     # Generic execution extensions
@@ -99,9 +99,9 @@ class IssueMetadata(BaseModel):
     
     id: str
     uid: Optional[str] = None  # Global unique identifier for cross-project identity
-    type: IssueType
-    status: IssueStatus = IssueStatus.OPEN
-    stage: Optional[IssueStage] = None
+    type: str
+    status: str = "open"
+    stage: Optional[str] = None
     title: str
     
     # Time Anchors
@@ -112,7 +112,7 @@ class IssueMetadata(BaseModel):
 
     parent: Optional[str] = None
     sprint: Optional[str] = None
-    solution: Optional[IssueSolution] = None
+    solution: Optional[str] = None
     isolation: Optional[IssueIsolation] = None
     dependencies: List[str] = []
     related: List[str] = []
@@ -120,13 +120,30 @@ class IssueMetadata(BaseModel):
     path: Optional[str] = None  # Absolute path to the issue file
     
     # Proxy UI Actions (Excluded from file persistence)
-    actions: List[IssueAction] = Field(default=[], exclude=True)
+    # Modified: Remove exclude=True to allow API/CLI inspection. Must be manually excluded during YAML Dump.
+    actions: List[IssueAction] = Field(default=[])
 
 
     @model_validator(mode='before')
     @classmethod
     def normalize_fields(cls, v: Any) -> Any:
         if isinstance(v, dict):
+            # Handle common capitalization variations for robustness
+            field_map = {
+                "ID": "id",
+                "Type": "type",
+                "Status": "status",
+                "Stage": "stage",
+                "Title": "title",
+                "Parent": "parent",
+                "Solution": "solution",
+                "Sprint": "sprint",
+            }
+            for old_k, new_k in field_map.items():
+                if old_k in v and new_k not in v:
+                    v[new_k] = v[old_k] # Don't pop yet to avoid mutation issues if used elsewhere, or pop if safe.
+                    # Pydantic v2 mode='before' is usually a copy if we want to be safe, but let's just add it.
+
             # Normalize type and status to lowercase for compatibility
             if "type" in v and isinstance(v["type"], str):
                 v["type"] = v["type"].lower()

monoco/features/issue/resources/zh/SKILL.md

@@ -38,7 +38,7 @@ Monoco 不仅仅复刻 Jira，而是基于 **"思维模式 (Mindset)"** 重新
 - **Focus**: "How" (为了支撑系统运转，必须做什么)。
 - **Prefix**: `CHORE-`
 
-> 注：取代了传统的 Task 概念。
+> 注: 取代了传统的 Task 概念。
 
 #### 🐞 FIX (修复)
 
@@ -47,7 +47,7 @@ Monoco 不仅仅复刻 Jira，而是基于 **"思维模式 (Mindset)"** 重新
 - **Focus**: "Fix" (恢复原状)。
 - **Prefix**: `FIX-`
 
-> 注：取代了传统的 Bug 概念。
+> 注: 取代了传统的 Bug 概念。
 
 ---
 
@@ -68,10 +68,9 @@ Monoco 不仅仅复刻 Jira，而是基于 **"思维模式 (Mindset)"** 重新
 
 ### 路径流转
 
-使用 `monoco issue`：
+使用 `monoco issue`:
 
 1. **Create**: `monoco issue create <type> --title "..."`
-
    - Params: `--parent <id>`, `--dependency <id>`, `--related <id>`, `--sprint <id>`, `--tags <tag>`
 
 2. **Transition**: `monoco issue open/close/backlog <id>`
@@ -87,13 +86,13 @@ Monoco 不仅仅复刻 Jira，而是基于 **"思维模式 (Mindset)"** 重新
 
 ## 合规与结构校验 (Validation Rules)
 
-为了确保数据严谨性，所有 Issue Ticket 必须遵循以下强制规则：
+为了确保数据严谨性，所有 Issue Ticket 必须遵循以下强制规则:
 
 ### 1. 结构一致性 (Structural Consistency)
 
 - 必须包含一个二级标题 (`##`)，内容必须与 Front Matter 中的 ID 和 Title 严格匹配。
-- 格式：`## {ID}: {Title}`
-- 示例：`## FEAT-0082: Issue Ticket Validator`
+- 格式: `## {ID}: {Title}`
+- 示例: `## FEAT-0082: Issue Ticket Validator`
 
 ### 2. 内容完整性 (Content Completeness)
 
@@ -103,11 +102,11 @@ Monoco 不仅仅复刻 Jira，而是基于 **"思维模式 (Mindset)"** 重新
 ### 3. Checkbox 语法与层级 (Checkbox Matrix)
 
 - 仅限使用: `- [ ]`, `- [x]`, `- [-]`, `- [/]`。
-- **层级继承**: 若存在嵌套 Checkbox，父项状态必须正确反映子项的聚合结果（例如：任一子项为 `[/]` 则父项必为 `[/]`；子项全选则父项为 `[x]`）。
+- **层级继承**: 若存在嵌套 Checkbox，父项状态必须正确反映子项的聚合结果（例如: 任一子项为 `[/]` 则父项必为 `[/]`；子项全选则父项为 `[x]`）。
 
 ### 4. 状态矩阵 (State Matrix)
 
-`status` (物理存放目录) 与 `stage` (Front Matter 字段) 必须兼容：
+`status` (物理存放目录) 与 `stage` (Front Matter 字段) 必须兼容:
 
 - **open**: Draft, Doing, Review, Done
 - **backlog**: Draft, Doing, Review