monoco-toolkit 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

monoco/features/issue/validator.py

@@ -4,7 +4,11 @@ from typing import List, Set, Optional, Dict
 from pathlib import Path
 
 from monoco.core.lsp import Diagnostic, DiagnosticSeverity, Range, Position
-from .models import IssueMetadata, IssueStatus, IssueStage, IssueType
+from monoco.core.config import get_config
+from monoco.features.i18n.core import detect_language
+from .models import IssueMetadata, IssueType
+from .domain.parser import MarkdownParser
+from .domain.models import ContentBlock
 
 class IssueValidator:
     """
@@ -18,14 +22,41 @@ class IssueValidator:
     def validate(self, meta: IssueMetadata, content: str, all_issue_ids: Set[str] = set()) -> List[Diagnostic]:
         diagnostics = []
         
+        # Parse Content into Blocks (Domain Layer)
+        # Handle case where content might be just body (from update_issue) or full file
+        if content.startswith("---"):
+            try:
+                issue_domain = MarkdownParser.parse(content)
+                blocks = issue_domain.body.blocks
+                has_frontmatter = True
+            except Exception:
+                # Fallback if parser fails (e.g. invalid YAML)
+                # We continue with empty blocks or try partial parsing?
+                # For now, let's try to parse blocks ignoring FM
+                lines = content.splitlines()
+                # Find end of FM
+                start_line = 0
+                if lines[0].strip() == "---":
+                    for i in range(1, len(lines)):
+                        if lines[i].strip() == "---":
+                            start_line = i + 1
+                            break
+                blocks = MarkdownParser._parse_blocks(lines[start_line:], start_line_offset=start_line)
+                has_frontmatter = True
+        else:
+            # Assume content is just body
+            lines = content.splitlines()
+            blocks = MarkdownParser._parse_blocks(lines, start_line_offset=0)
+            has_frontmatter = False
+
         # 1. State Matrix Validation
         diagnostics.extend(self._validate_state_matrix(meta, content))
         
-        # 2. Content Completeness (Checkbox check)
-        diagnostics.extend(self._validate_content_completeness(meta, content))
+        # 2. State Requirements (Strict Verification)
+        diagnostics.extend(self._validate_state_requirements(meta, blocks))
         
-        # 3. Structure Consistency (Headings)
-        diagnostics.extend(self._validate_structure(meta, content))
+        # 3. Structure Consistency (Headings) - Using Blocks
+        diagnostics.extend(self._validate_structure_blocks(meta, blocks))
         
         # 4. Lifecycle/Integrity (Solution, etc.)
         diagnostics.extend(self._validate_integrity(meta, content))
@@ -36,9 +67,30 @@ class IssueValidator:
         # 6. Time Consistency
         diagnostics.extend(self._validate_time_consistency(meta, content))
 
-        # 7. Checkbox Syntax
-        diagnostics.extend(self._validate_checkbox_logic(content))
+        # 7. Checkbox Syntax - Using Blocks
+        diagnostics.extend(self._validate_checkbox_logic_blocks(blocks))
         
+        # 8. Language Consistency
+        diagnostics.extend(self._validate_language_consistency(meta, content))
+
+        return diagnostics
+
+    def _validate_language_consistency(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
+        diagnostics = []
+        try:
+            config = get_config()
+            source_lang = config.i18n.source_lang
+            
+            # Check for language mismatch (specifically zh vs en)
+            if source_lang.lower() == 'zh':
+                detected = detect_language(content)
+                if detected == 'en':
+                     diagnostics.append(self._create_diagnostic(
+                         "Language Mismatch: Project source language is 'zh' but content appears to be 'en'.",
+                         DiagnosticSeverity.Warning
+                     ))
+        except Exception:
+            pass
         return diagnostics
 
     def _create_diagnostic(self, message: str, severity: DiagnosticSeverity, line: int = 0) -> Diagnostic:
@@ -74,56 +126,102 @@ class IssueValidator:
         diagnostics = []
         
         # Check based on parsed metadata (now that auto-correction is disabled)
-        if meta.status == IssueStatus.CLOSED and meta.stage != IssueStage.DONE:
+        if meta.status == "closed" and meta.stage != "done":
             line = self._get_field_line(content, "status")
             diagnostics.append(self._create_diagnostic(
-                f"State Mismatch: Closed issues must be in 'Done' stage (found: {meta.stage.value if meta.stage else 'None'})", 
+                f"State Mismatch: Closed issues must be in 'Done' stage (found: {meta.stage if meta.stage else 'None'})", 
                 DiagnosticSeverity.Error,
                 line=line
             ))
         
-        if meta.status == IssueStatus.BACKLOG and meta.stage != IssueStage.FREEZED:
+        if meta.status == "backlog" and meta.stage != "freezed":
             line = self._get_field_line(content, "status")
             diagnostics.append(self._create_diagnostic(
-                f"State Mismatch: Backlog issues must be in 'Freezed' stage (found: {meta.stage.value if meta.stage else 'None'})", 
+                f"State Mismatch: Backlog issues must be in 'Freezed' stage (found: {meta.stage if meta.stage else 'None'})", 
                 DiagnosticSeverity.Error,
                 line=line
             ))
 
         return diagnostics
 
-    def _validate_content_completeness(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
+    def _validate_state_requirements(self, meta: IssueMetadata, blocks: List[ContentBlock]) -> List[Diagnostic]:
         diagnostics = []
-        # Checkbox regex: - [ ] or - [x] or - [-] or - [/]
-        checkboxes = re.findall(r"-\s*\[([ x\-/])\]", content)
         
-        if len(checkboxes) < 2:
-            diagnostics.append(self._create_diagnostic(
-                "Content Incomplete: Ticket must contain at least 2 checkboxes (AC & Tasks).",
-                DiagnosticSeverity.Warning
-            ))
-            
-        if meta.stage in [IssueStage.REVIEW, IssueStage.DONE]:
-            # No empty checkboxes allowed
-            if ' ' in checkboxes:
-                # Find the first occurrence line
-                lines = content.split('\n')
-                first_line = 0
-                for i, line in enumerate(lines):
-                    if re.search(r"-\s*\[ \]", line):
-                        first_line = i
-                        break
-                        
-                diagnostics.append(self._create_diagnostic(
-                    f"Incomplete Tasks: Issue in {meta.stage} cannot have unchecked boxes.",
-                    DiagnosticSeverity.Error,
-                    line=first_line
-                ))
+        # 1. Map Blocks to Sections
+        sections = {"tasks": [], "ac": [], "review": []}
+        current_section = None
+        
+        for block in blocks:
+            if block.type == "heading":
+                title = block.content.strip().lower()
+                if "technical tasks" in title:
+                    current_section = "tasks"
+                elif "acceptance criteria" in title:
+                    current_section = "ac"
+                elif "review comments" in title:
+                    current_section = "review"
+                else:
+                    current_section = None
+            elif block.type == "task_item":
+                if current_section and current_section in sections:
+                    sections[current_section].append(block)
+
+        # 2. Logic: DOING -> Must have defined tasks
+        if meta.stage in ["doing", "review", "done"]:
+             if not sections["tasks"]:
+                 # We can't strictly point to a line if section missing, but we can point to top/bottom
+                 # Or just a general error.
+                 diagnostics.append(self._create_diagnostic(
+                     "State Requirement (DOING+): Must define 'Technical Tasks' (at least 1 checkbox).",
+                     DiagnosticSeverity.Warning
+                 ))
+
+        # 3. Logic: REVIEW -> Tasks must be Completed ([x]) or Cancelled ([~], [+])
+        # No [ ] (ToDo) or [-]/[/] (Doing) allowed.
+        if meta.stage in ["review", "done"]:
+            for block in sections["tasks"]:
+                 content = block.content.strip()
+                 # Check for explicit illegal states
+                 if re.search(r"-\s*\[\s+\]", content):
+                      diagnostics.append(self._create_diagnostic(
+                          f"State Requirement ({meta.stage.upper()}): Technical Tasks must be resolved. Found Todo [ ]: '{content}'",
+                          DiagnosticSeverity.Error,
+                          line=block.line_start
+                      ))
+                 elif re.search(r"-\s*\[[-\/]]", content):
+                      diagnostics.append(self._create_diagnostic(
+                          f"State Requirement ({meta.stage.upper()}): Technical Tasks must be finished (not Doing). Found Doing [-]: '{content}'",
+                          DiagnosticSeverity.Error,
+                          line=block.line_start
+                      ))
+
+        # 4. Logic: DONE -> AC must be Verified ([x])
+        if meta.stage == "done":
+             for block in sections["ac"]:
+                 content = block.content.strip()
+                 if not re.search(r"-\s*\[[xX]\]", content):
+                      diagnostics.append(self._create_diagnostic(
+                          f"State Requirement (DONE): Acceptance Criteria must be passed ([x]). Found: '{content}'",
+                          DiagnosticSeverity.Error,
+                          line=block.line_start
+                      ))
+             
+             # 5. Logic: DONE -> Review Checkboxes (if any) must be Resolved ([x] or [~])
+             for block in sections["review"]:
+                 content = block.content.strip()
+                 # Must be [x], [X], [~], [+]
+                 # Therefore [ ], [-], [/] are invalid blocking states
+                 if re.search(r"-\s*\[[\s\-\/]\]", content):
+                      diagnostics.append(self._create_diagnostic(
+                          f"State Requirement (DONE): Actionable Review Comments must be resolved ([x] or [~]). Found: '{content}'",
+                          DiagnosticSeverity.Error,
+                          line=block.line_start
+                      ))
+                      
         return diagnostics
 
-    def _validate_structure(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
+    def _validate_structure_blocks(self, meta: IssueMetadata, blocks: List[ContentBlock]) -> List[Diagnostic]:
         diagnostics = []
-        lines = content.split('\n')
         
         # 1. Heading check: ## {issue-id}: {issue-title}
         expected_header = f"## {meta.id}: {meta.title}"
@@ -133,19 +231,25 @@ class IssueValidator:
         review_header_found = False
         review_content_found = False
         
-        for i, line in enumerate(lines):
-            line_stripped = line.strip()
-            if line_stripped == expected_header:
-                header_found = True
-            
-            if line_stripped == "## Review Comments":
-                review_header_found = True
-                # Check near lines for content
-                # This is a naive check (next line is not empty)
-                if i + 1 < len(lines) and lines[i+1].strip():
-                     review_content_found = True
-                elif i + 2 < len(lines) and lines[i+2].strip():
-                     review_content_found = True
+        review_header_index = -1
+        
+        for i, block in enumerate(blocks):
+            if block.type == 'heading':
+                stripped = block.content.strip()
+                if stripped == expected_header:
+                    header_found = True
+                
+                if stripped == "## Review Comments":
+                    review_header_found = True
+                    review_header_index = i
+        
+        # Check content after review header
+        if review_header_found:
+            # Check if there are blocks after review_header_index that are NOT empty
+            for j in range(review_header_index + 1, len(blocks)):
+                if blocks[j].type != 'empty':
+                    review_content_found = True
+                    break
 
         if not header_found:
              diagnostics.append(self._create_diagnostic(
@@ -153,7 +257,7 @@ class IssueValidator:
                  DiagnosticSeverity.Warning
              ))
              
-        if meta.stage in [IssueStage.REVIEW, IssueStage.DONE]:
+        if meta.stage in ["review", "done"]:
             if not review_header_found:
                 diagnostics.append(self._create_diagnostic(
                     "Review Requirement: Missing '## Review Comments' section.",
@@ -168,7 +272,7 @@ class IssueValidator:
 
     def _validate_integrity(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
         diagnostics = []
-        if meta.status == IssueStatus.CLOSED and not meta.solution:
+        if meta.status == "closed" and not meta.solution:
             line = self._get_field_line(content, "status")
             diagnostics.append(self._create_diagnostic(
                 f"Data Integrity: Closed issue {meta.id} missing 'solution' field.",
@@ -198,6 +302,42 @@ class IssueValidator:
                     DiagnosticSeverity.Error,
                     line=line
                  ))
+                 
+        # Body Reference Check
+        # Regex for generic issue ID: (EPIC|FEAT|CHORE|FIX)-\d{4}
+        # We scan line by line to get line numbers
+        lines = content.split('\n')
+        # Skip frontmatter for body check to avoid double counting (handled above)
+        in_fm = False
+        fm_end = 0
+        for i, line in enumerate(lines):
+            if line.strip() == '---':
+                if not in_fm: in_fm = True
+                else: 
+                    fm_end = i
+                    break
+        
+        for i, line in enumerate(lines):
+            if i <= fm_end: continue # Skip frontmatter
+            
+            # Find all matches
+            matches = re.finditer(r"\b((?:EPIC|FEAT|CHORE|FIX)-\d{4})\b", line)
+            for match in matches:
+                ref_id = match.group(1)
+                if ref_id != meta.id and ref_id not in all_ids:
+                     # Check if it's a namespaced ID? The regex only catches local IDs.
+                     # If users use MON::FEAT-0001, the regex might catch FEAT-0001.
+                     # But all_ids contains full IDs (potentially namespaced).
+                     # Simple logic: if ref_id isn't in all_ids, check if any id ENDS with ref_id
+                     
+                     found_namespaced = any(known.endswith(f"::{ref_id}") for known in all_ids)
+                     
+                     if not found_namespaced:
+                        diagnostics.append(self._create_diagnostic(
+                            f"Broken Reference: Issue '{ref_id}' not found.",
+                            DiagnosticSeverity.Warning,
+                            line=i
+                        ))
         return diagnostics
 
     def _validate_time_consistency(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
@@ -226,21 +366,20 @@ class IssueValidator:
 
         return diagnostics
 
-    def _validate_checkbox_logic(self, content: str) -> List[Diagnostic]:
+    def _validate_checkbox_logic_blocks(self, blocks: List[ContentBlock]) -> List[Diagnostic]:
         diagnostics = []
-        lines = content.split('\n')
         
-        for i, line in enumerate(lines):
-            stripped = line.lstrip()
-            
-            # Syntax Check: - [?]
-            if stripped.startswith("- ["):
-                match = re.match(r"- \[([ x\-/])\]", stripped)
+        for block in blocks:
+            if block.type == 'task_item':
+                content = block.content.strip()
+                # Syntax Check: - [?]
+                # Added supported chars: /, ~, +
+                match = re.match(r"- \[([ x\-/~+])\]", content)
                 if not match:
                     # Check for Common errors
-                    if re.match(r"- \[.{2,}\]", stripped): # [xx] or [  ]
-                         diagnostics.append(self._create_diagnostic("Invalid Checkbox: Use single character [ ], [x], [-], [/]", DiagnosticSeverity.Error, i))
-                    elif re.match(r"- \[([^ x\-/])\]", stripped): # [v], [o]
-                         diagnostics.append(self._create_diagnostic("Invalid Checkbox Status: Use [ ], [x], [-], [/]", DiagnosticSeverity.Error, i))
+                    if re.match(r"- \[.{2,}\]", content): # [xx] or [  ]
+                         diagnostics.append(self._create_diagnostic("Invalid Checkbox: Use single character [ ], [x], [-], [/]", DiagnosticSeverity.Error, block.line_start))
+                    elif re.match(r"- \[([^ x\-/~+])\]", content): # [v], [o]
+                         diagnostics.append(self._create_diagnostic("Invalid Checkbox Status: Use [ ], [x], [/], [~]", DiagnosticSeverity.Error, block.line_start))
         
         return diagnostics

monoco/features/spike/commands.py

@@ -1,15 +1,18 @@
 import typer
 from pathlib import Path
 from rich.console import Console
+from typing import Annotated
 
 from monoco.core.config import get_config
+from monoco.core.output import AgentOutput, OutputManager
 from . import core
 
 app = typer.Typer(help="Spike & Repo Management.")
-console = Console()
 
 @app.command("init")
-def init():
+def init(
+    json: AgentOutput = False,
+):
     """Initialize the Spike environment (gitignore setup)."""
     config = get_config()
     root_dir = Path(config.paths.root)
@@ -20,11 +23,16 @@ def init():
     # Create the directory
     (root_dir / spikes_dir_name).mkdir(exist_ok=True)
     
-    console.print(f"[green]✔[/green] Initialized Spike environment. Added '{spikes_dir_name}/' to .gitignore.")
+    OutputManager.print({
+        "status": "initialized",
+        "directory": spikes_dir_name,
+        "gitignore_updated": True
+    })
 
 @app.command("add")
 def add_repo(
     url: str = typer.Argument(..., help="Git Repository URL"),
+    json: AgentOutput = False,
 ):
     """Add a new research repository."""
     config = get_config()
@@ -38,13 +46,18 @@ def add_repo(
         name = name[:-4]
         
     core.update_config_repos(root_dir, name, url)
-    console.print(f"[green]✔[/green] Added repo [bold]{name}[/bold] ({url}) to configuration.")
-    console.print("Run [bold]monoco spike sync[/bold] to download content.")
+    OutputManager.print({
+        "status": "added",
+        "name": name,
+        "url": url,
+        "message": f"Run 'monoco spike sync' to download content."
+    })
 
 @app.command("remove")
 def remove_repo(
     name: str = typer.Argument(..., help="Repository Name"),
     force: bool = typer.Option(False, "--force", "-f", help="Force delete physical directory without asking"),
+    json: AgentOutput = False,
 ):
     """Remove a repository from configuration."""
     config = get_config()
@@ -52,30 +65,34 @@ def remove_repo(
     spikes_dir = root_dir / config.paths.spikes
     
     if name not in config.project.spike_repos:
-        console.print(f"[yellow]![/yellow] Repo [bold]{name}[/bold] not found in configuration.")
+        OutputManager.error(f"Repo {name} not found in configuration.")
         return
 
     # Remove from config
     core.update_config_repos(root_dir, name, "", remove=True)
-    console.print(f"[green]✔[/green] Removed [bold]{name}[/bold] from configuration.")
     
     target_path = spikes_dir / name
+    deleted = False
     if target_path.exists():
         if force or typer.confirm(f"Do you want to delete the directory {target_path}?", default=False):
             core.remove_repo_dir(spikes_dir, name)
-            console.print(f"[gray]✔[/gray] Deleted directory {target_path}.")
+            deleted = True
         else:
-            console.print(f"[gray]ℹ[/gray] Directory {target_path} kept.")
+            deleted = False
+            
+    OutputManager.print({
+        "status": "removed",
+        "name": name,
+        "directory_deleted": deleted
+    })
 
 @app.command("sync")
-def sync_repos():
+def sync_repos(
+    json: AgentOutput = False,
+):
     """Sync (Clone/Pull) all configured repositories."""
     # Force reload config to get latest updates
     config = get_config()
-    # Note: get_config is a singleton, so for 'add' then 'sync' in same process, 
-    # we rely on 'add' writing to disk and us reading from memory? 
-    # Actually, if we run standard CLI "monoco spike add" then "monoco spike sync", 
-    # they are separate processes, so config loads fresh.
     
     root_dir = Path(config.paths.root)
     spikes_dir = root_dir / config.paths.spikes
@@ -84,27 +101,31 @@ def sync_repos():
     repos = config.project.spike_repos
     
     if not repos:
-        console.print("[yellow]No repositories configured.[/yellow] Use 'monoco spike add <url>' first.")
+        OutputManager.print({"status": "empty", "message": "No repositories configured."}, title="Sync")
         return
         
-    console.print(f"Syncing {len(repos)} repositories...")
+    results = []
     
     for name, url in repos.items():
-        core.sync_repo(root_dir, spikes_dir, name, url)
+        try:
+            core.sync_repo(root_dir, spikes_dir, name, url)
+            results.append({"name": name, "status": "synced", "url": url})
+        except Exception as e:
+             results.append({"name": name, "status": "failed", "error": str(e), "url": url})
         
-    console.print("[green]✔[/green] Sync complete.")
+    OutputManager.print(results, title="Sync Results")
 
-# Alias for list (showing configured repos) could be useful but not strictly asked for.
-# Let's add a simple list command to see what we have.
 @app.command("list")
-def list_repos():
+def list_repos(
+    json: AgentOutput = False,
+):
     """List configured repositories."""
     config = get_config()
     repos = config.project.spike_repos
     
     if not repos:
-        console.print("[yellow]No repositories configured.[/yellow]")
+        OutputManager.print([], title="Repositories")
         return
         
-    for name, url in repos.items():
-        console.print(f"- [bold]{name}[/bold]: {url}")
+    data = [{"name": name, "url": url} for name, url in repos.items()]
+    OutputManager.print(data, title="Repositories")

monoco/features/spike/core.py

@@ -1,12 +1,12 @@
 import os
 import shutil
 import subprocess
-import yaml
+
 from pathlib import Path
 from typing import Dict, Optional, List, Any
 from rich.console import Console
 
-from monoco.core.config import get_config
+from monoco.core.config import get_config, load_raw_config, save_raw_config, ConfigScope
 
 console = Console()
 
@@ -29,26 +29,10 @@ def run_git_command(cmd: List[str], cwd: Path) -> bool:
         console.print("[red]Error:[/red] git command not found.")
         return False
 
-def get_config_file_path(root: Path) -> Path:
-    """Determine the config file to update."""
-    # Standard: .monoco/config.yaml
-    hidden = root / ".monoco" / "config.yaml"
-    
-    # Ensure parent exists
-    hidden.parent.mkdir(exist_ok=True)
-    return hidden
-
 def update_config_repos(root: Path, repo_name: str, repo_url: str, remove: bool = False):
     """Update the repos list in the config file."""
-    config_path = get_config_file_path(root)
-    
-    data = {}
-    if config_path.exists():
-        try:
-            with open(config_path, "r") as f:
-                data = yaml.safe_load(f) or {}
-        except Exception:
-            data = {}
+    # Use core config utils
+    data = load_raw_config(ConfigScope.PROJECT, project_root=str(root))
             
     # Ensure structure exists
     if "project" not in data:
@@ -62,8 +46,7 @@ def update_config_repos(root: Path, repo_name: str, repo_url: str, remove: bool
     else:
         data["project"]["spike_repos"][repo_name] = repo_url
         
-    with open(config_path, "w") as f:
-        yaml.dump(data, f, sort_keys=False, default_flow_style=False)
+    save_raw_config(ConfigScope.PROJECT, data, project_root=str(root))
 
 def ensure_gitignore(root: Path, target_dir_name: str):
     """Ensure the target directory is in .gitignore."""

monoco/main.py

@@ -63,7 +63,7 @@ def main(
     NO_WORKSPACE_COMMANDS = ["init", "clone"] 
     
     # Initialize Config
-    from monoco.core.config import get_config
+    from monoco.core.config import get_config, find_monoco_root
     from pathlib import Path
 
     # If subcommand is not in whitelist, we enforce workspace
@@ -74,7 +74,16 @@ def main(
     try:
         # We pass root if provided. If require_workspace is True, get_config will throw if not found.
         # Note: If root is None, it defaults to CWD in get_config.
-        get_config(project_root=root, require_project=require_workspace)
+        
+        # Auto-discover root if not provided
+        config_root = root
+        if config_root is None:
+            discovered = find_monoco_root()
+            # Only use discovered root if it actually has .monoco
+            if (discovered / ".monoco").exists():
+                config_root = str(discovered)
+        
+        get_config(project_root=config_root, require_project=require_workspace)
     except FileNotFoundError as e:
         # Graceful exit for workspace errors
         from rich.console import Console
@@ -158,20 +167,5 @@ app.add_typer(agent_cmd.app, name="agent", help="Delegate tasks to Agent CLIs")
 from monoco.daemon.commands import serve
 app.command(name="serve")(serve)
 
-@app.command()
-def pty(
-    host: str = "127.0.0.1",
-    port: int = 3124,
-    cwd: Optional[str] = None
-):
-    """
-    Start the Monoco PTY Daemon (WebSocket).
-    """
-    from monoco.features.pty.server import run_pty_server
-    from pathlib import Path
-    
-    path = Path(cwd) if cwd else None
-    run_pty_server(host, port, path)
-
 if __name__ == "__main__":
     app()

{monoco_toolkit-0.2.4.dist-info → monoco_toolkit-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monoco-toolkit
-Version: 0.2.4
+Version: 0.2.6
 Summary: Agent Native Toolkit for Monoco - Task Management & Kanban for AI Agents
 Project-URL: Homepage, https://monoco.io
 Project-URL: Repository, https://github.com/IndenScale/Monoco