monoco-toolkit 0.1.5__py3-none-any.whl

monoco/daemon/services.py

@@ -0,0 +1,265 @@
+import asyncio
+import logging
+import subprocess
+import os
+import re
+from typing import List, Optional, Dict, Any
+from asyncio import Queue
+from pathlib import Path
+
+from monoco.features.issue.core import parse_issue, IssueMetadata
+import json
+
+logger = logging.getLogger("monoco.daemon.services")
+
+class Broadcaster:
+    """
+    Manages SSE subscriptions and broadcasts events to all connected clients.
+    """
+    def __init__(self):
+        self.subscribers: List[Queue] = []
+
+    async def subscribe(self) -> Queue:
+        queue = Queue()
+        self.subscribers.append(queue)
+        logger.info(f"New client subscribed. Total clients: {len(self.subscribers)}")
+        return queue
+
+    async def unsubscribe(self, queue: Queue):
+        if queue in self.subscribers:
+            self.subscribers.remove(queue)
+            logger.info(f"Client unsubscribed. Total clients: {len(self.subscribers)}")
+
+    async def broadcast(self, event_type: str, payload: dict):
+        if not self.subscribers:
+            return
+        
+        message = {
+            "event": event_type,
+            "data": json.dumps(payload)
+        }
+        
+        # Dispatch to all queues
+        for queue in self.subscribers:
+            await queue.put(message)
+        
+        logger.debug(f"Broadcasted {event_type} to {len(self.subscribers)} clients.")
+
+
+class GitMonitor:
+    """
+    Polls the Git repository for HEAD changes and triggers updates.
+    """
+    def __init__(self, broadcaster: Broadcaster, poll_interval: float = 2.0):
+        self.broadcaster = broadcaster
+        self.poll_interval = poll_interval
+        self.last_head_hash: Optional[str] = None
+        self.is_running = False
+
+    async def get_head_hash(self) -> Optional[str]:
+        try:
+            # Run git rev-parse HEAD asynchronously
+            process = await asyncio.create_subprocess_exec(
+                "git", "rev-parse", "HEAD",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE
+            )
+            stdout, _ = await process.communicate()
+            if process.returncode == 0:
+                return stdout.decode().strip()
+            return None
+        except Exception as e:
+            logger.error(f"Git polling error: {e}")
+            return None
+
+    async def start(self):
+        self.is_running = True
+        logger.info("Git Monitor started.")
+        
+        # Initial check
+        self.last_head_hash = await self.get_head_hash()
+        
+        while self.is_running:
+            await asyncio.sleep(self.poll_interval)
+            current_hash = await self.get_head_hash()
+            
+            if current_hash and current_hash != self.last_head_hash:
+                logger.info(f"Git HEAD changed: {self.last_head_hash} -> {current_hash}")
+                self.last_head_hash = current_hash
+                await self.broadcaster.broadcast("HEAD_UPDATED", {
+                    "ref": "HEAD",
+                    "hash": current_hash
+                })
+
+    def stop(self):
+        self.is_running = False
+        logger.info("Git Monitor stopping...")
+
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+from monoco.core.config import MonocoConfig, get_config
+
+class ProjectContext:
+    """
+    Holds the runtime state for a single project.
+    """
+    def __init__(self, path: Path, config: MonocoConfig, broadcaster: Broadcaster):
+        self.path = path
+        self.config = config
+        self.id = path.name  # Use directory name as ID for now
+        self.name = config.project.name
+        self.issues_root = path / config.paths.issues
+        self.monitor = IssueMonitor(self.issues_root, broadcaster, project_id=self.id)
+
+    async def start(self):
+        await self.monitor.start()
+
+    def stop(self):
+        self.monitor.stop()
+
+class ProjectManager:
+    """
+    Discovers and manages multiple Monoco projects within a workspace.
+    """
+    def __init__(self, workspace_root: Path, broadcaster: Broadcaster):
+        self.workspace_root = workspace_root
+        self.broadcaster = broadcaster
+        self.projects: Dict[str, ProjectContext] = {}
+
+    def scan(self):
+        """
+        Scans workspace for potential Monoco projects.
+        A directory is a project if it has monoco.yaml or .monoco/config.yaml or an Issues directory.
+        """
+        logger.info(f"Scanning workspace: {self.workspace_root}")
+        from monoco.core.workspace import find_projects
+        
+        projects = find_projects(self.workspace_root)
+        for p in projects:
+            self._register_project(p)
+
+    def _register_project(self, path: Path):
+        try:
+            config = get_config(str(path))
+            # If name is default, try to use directory name
+            if config.project.name == "Monoco Project":
+                config.project.name = path.name
+            
+            ctx = ProjectContext(path, config, self.broadcaster)
+            self.projects[ctx.id] = ctx
+            logger.info(f"Registered project: {ctx.id} ({ctx.path})")
+        except Exception as e:
+            logger.error(f"Failed to register project at {path}: {e}")
+
+    async def start_all(self):
+        self.scan()
+        for project in self.projects.values():
+            await project.start()
+
+    def stop_all(self):
+        for project in self.projects.values():
+            project.stop()
+
+    def get_project(self, project_id: str) -> Optional[ProjectContext]:
+        return self.projects.get(project_id)
+
+    def list_projects(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "id": p.id,
+                "name": p.name,
+                "path": str(p.path),
+                "issues_path": str(p.issues_root)
+            }
+            for p in self.projects.values()
+        ]
+
+class IssueEventHandler(FileSystemEventHandler):
+    def __init__(self, loop, broadcaster: Broadcaster, project_id: str):
+        self.loop = loop
+        self.broadcaster = broadcaster
+        self.project_id = project_id
+
+    def _process_upsert(self, path_str: str):
+        if not path_str.endswith(".md"):
+            return
+        asyncio.run_coroutine_threadsafe(self._handle_upsert(path_str), self.loop)
+    
+    async def _handle_upsert(self, path_str: str):
+        try:
+            path = Path(path_str)
+            if not path.exists():
+                return
+            issue = parse_issue(path)
+            if issue:
+                await self.broadcaster.broadcast("issue_upserted", {
+                    "issue": issue.model_dump(mode='json'),
+                    "project_id": self.project_id
+                })
+        except Exception as e:
+            logger.error(f"Error handling upsert for {path_str}: {e}")
+
+    def _process_delete(self, path_str: str):
+        if not path_str.endswith(".md"):
+            return
+        asyncio.run_coroutine_threadsafe(self._handle_delete(path_str), self.loop)
+
+    async def _handle_delete(self, path_str: str):
+        try:
+            filename = Path(path_str).name
+            match = re.match(r"([A-Z]+-\d{4})", filename)
+            if match:
+                issue_id = match.group(1)
+                await self.broadcaster.broadcast("issue_deleted", {
+                    "id": issue_id,
+                    "project_id": self.project_id
+                })
+        except Exception as e:
+            logger.error(f"Error handling delete for {path_str}: {e}")
+
+    def on_created(self, event):
+        if not event.is_directory:
+            self._process_upsert(event.src_path)
+
+    def on_modified(self, event):
+        if not event.is_directory:
+            self._process_upsert(event.src_path)
+            
+    def on_deleted(self, event):
+        if not event.is_directory:
+            self._process_delete(event.src_path)
+
+    def on_moved(self, event):
+        if not event.is_directory:
+            self._process_delete(event.src_path)
+            self._process_upsert(event.dest_path)
+
+class IssueMonitor:
+    """
+    Monitor the Issues directory for changes using Watchdog and broadcast update events.
+    """
+    def __init__(self, issues_root: Path, broadcaster: Broadcaster, project_id: str):
+        self.issues_root = issues_root
+        self.broadcaster = broadcaster
+        self.project_id = project_id
+        self.observer = Observer()
+        self.loop = None
+
+    async def start(self):
+        self.loop = asyncio.get_running_loop()
+        event_handler = IssueEventHandler(self.loop, self.broadcaster, self.project_id)
+        
+        # Ensure directory exists
+        if not self.issues_root.exists():
+            logger.warning(f"Issues root {self.issues_root} does not exist. creating...")
+            self.issues_root.mkdir(parents=True, exist_ok=True)
+
+        self.observer.schedule(event_handler, str(self.issues_root), recursive=True)
+        self.observer.start()
+        logger.info(f"Issue Monitor started (Watchdog). Watching {self.issues_root}")
+
+    def stop(self):
+        if self.observer.is_alive():
+            self.observer.stop()
+            self.observer.join()
+        logger.info("Issue Monitor stopped.")

monoco/daemon/stats.py

@@ -0,0 +1,124 @@
+from typing import List, Dict, Set, Optional
+from datetime import datetime, timedelta
+from pathlib import Path
+from enum import Enum
+from pydantic import BaseModel
+from monoco.features.issue.core import list_issues
+from monoco.features.issue.models import IssueStatus, IssueMetadata
+
+class ActivityType(str, Enum):
+    CREATED = "created"
+    UPDATED = "updated"
+    CLOSED = "closed"
+
+class ActivityItem(BaseModel):
+    id: str
+    type: ActivityType
+    issue_id: str
+    issue_title: str
+    timestamp: datetime
+    description: Optional[str] = None
+
+class DashboardStats(BaseModel):
+    total_backlog: int
+    completed_this_week: int
+    blocked_issues_count: int
+    velocity_trend: int  # Delta compared to last week
+    recent_activities: List[ActivityItem] = []
+    
+def calculate_dashboard_stats(issues_root: Path) -> DashboardStats:
+    raw_issues = list_issues(issues_root)
+    
+    # 1. Pre-process for fast lookup and deduplication
+    issue_map: Dict[str, IssueMetadata] = {i.id: i for i in raw_issues}
+    issues = list(issue_map.values())
+    
+    backlog_count = 0
+    completed_this_week = 0
+    completed_last_week = 0
+    blocked_count = 0
+    
+    now = datetime.now()
+    one_week_ago = now - timedelta(days=7)
+    two_weeks_ago = now - timedelta(days=14)
+    activity_window = now - timedelta(days=3) # Show activities from last 3 days
+    
+    activities: List[ActivityItem] = []
+
+    for issue in issues:
+        # --- Stats Calculation ---
+        # Total Backlog
+        if issue.status == IssueStatus.BACKLOG:
+            backlog_count += 1
+            
+        # Completed This Week & Last Week
+        if issue.status == IssueStatus.CLOSED and issue.closed_at:
+            closed_at = issue.closed_at
+            if closed_at >= one_week_ago:
+                completed_this_week += 1
+            elif closed_at >= two_weeks_ago and closed_at < one_week_ago:
+                completed_last_week += 1
+                
+        # Blocked Issues
+        if issue.status == IssueStatus.OPEN:
+            is_blocked = False
+            for dep_id in issue.dependencies:
+                dep_issue = issue_map.get(dep_id)
+                if not dep_issue or dep_issue.status != IssueStatus.CLOSED:
+                    is_blocked = True
+                    break
+            if is_blocked:
+                blocked_count += 1
+
+        # --- Activity Feed Generation ---
+        # 1. Created Event
+        if issue.created_at >= activity_window:
+            activities.append(ActivityItem(
+                id=f"act_create_{issue.id}",
+                type=ActivityType.CREATED,
+                issue_id=issue.id,
+                issue_title=issue.title,
+                timestamp=issue.created_at,
+                description="Issue created"
+            ))
+
+        # 2. Closed Event
+        if issue.status == IssueStatus.CLOSED and issue.closed_at and issue.closed_at >= activity_window:
+            activities.append(ActivityItem(
+                id=f"act_close_{issue.id}",
+                type=ActivityType.CLOSED,
+                issue_id=issue.id,
+                issue_title=issue.title,
+                timestamp=issue.closed_at,
+                description="Issue completed"
+            ))
+            
+        # 3. Updated Event (Heuristic: updated recently and not just created/closed)
+        # We skip 'updated' if it's too close to created_at or closed_at to avoid noise
+        if issue.updated_at >= activity_window:
+            is_creation = abs((issue.updated_at - issue.created_at).total_seconds()) < 60
+            is_closing = issue.closed_at and abs((issue.updated_at - issue.closed_at).total_seconds()) < 60
+            
+            if not is_creation and not is_closing:
+                 activities.append(ActivityItem(
+                    id=f"act_update_{issue.id}_{issue.updated_at.timestamp()}",
+                    type=ActivityType.UPDATED,
+                    issue_id=issue.id,
+                    issue_title=issue.title,
+                    timestamp=issue.updated_at,
+                    description="Issue updated"
+                ))
+
+    # Sort activities by timestamp desc and take top 20
+    activities.sort(key=lambda x: x.timestamp, reverse=True)
+    recent_activities = activities[:20]
+
+    velocity_trend = completed_this_week - completed_last_week
+    
+    return DashboardStats(
+        total_backlog=backlog_count,
+        completed_this_week=completed_this_week,
+        blocked_issues_count=blocked_count,
+        velocity_trend=velocity_trend,
+        recent_activities=recent_activities
+    )

monoco/features/config/commands.py

@@ -0,0 +1,70 @@
+import typer
+import yaml
+from pathlib import Path
+from typing import Optional
+from monoco.core.config import get_config, MonocoConfig
+from monoco.core.output import print_output
+from rich.console import Console
+
+app = typer.Typer(help="Manage Monoco configuration")
+console = Console()
+
+@app.command()
+def show():
+    """Show current configuration."""
+    settings = get_config()
+    print_output(settings, title="Current Configuration")
+
+@app.command(name="set")
+def set_val(
+    key: str = typer.Argument(..., help="Config key (e.g. telemetry.enabled)"),
+    value: str = typer.Argument(..., help="Value to set"),
+    scope: str = typer.Option("global", "--scope", "-s", help="Configuration scope: global or project")
+):
+    """Set a configuration value."""
+    # This is a simplified implementation of config setting
+    # In a real system, we'd want to validate the key against the schema
+    
+    if scope == "global":
+        config_path = Path.home() / ".monoco" / "config.yaml"
+    else:
+        # Check project root
+        cwd = Path.cwd()
+        config_path = cwd / ".monoco" / "config.yaml"
+        if not (cwd / ".monoco").exists():
+             config_path = cwd / "monoco.yaml"
+
+    config_data = {}
+    if config_path.exists():
+        with open(config_path, "r") as f:
+            config_data = yaml.safe_load(f) or {}
+
+    # Simple nested key support (e.g. telemetry.enabled)
+    parts = key.split(".")
+    target = config_data
+    for part in parts[:-1]:
+        if part not in target:
+            target[part] = {}
+        target = target[part]
+    
+    # Type conversion
+    if value.lower() in ("true", "yes", "on"):
+        val = True
+    elif value.lower() in ("false", "no", "off"):
+        val = False
+    else:
+        try:
+            val = int(value)
+        except ValueError:
+            val = value
+
+    target[parts[-1]] = val
+
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(config_path, "w") as f:
+        yaml.dump(config_data, f, default_flow_style=False)
+    
+    console.print(f"[green]✓ Set {key} = {val} in {scope} config.[/green]")
+
+if __name__ == "__main__":
+    app()

monoco/features/i18n/commands.py

@@ -0,0 +1,121 @@
+import typer
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from monoco.core.config import get_config
+from . import core
+
+app = typer.Typer(help="Management tools for Documentation Internationalization (i18n).")
+console = Console()
+
+@app.command("scan")
+def scan(
+    root: str = typer.Option(None, "--root", help="Target root directory to scan. Defaults to the project root."),
+    limit: int = typer.Option(10, "--limit", help="Maximum number of missing files to display. Use 0 for unlimited."),
+):
+    """
+    Scan the project for internationalization (i18n) status.
+
+    Scans all Markdown files in the target directory and checks for the existence of
+    translation files based on Monoco's i18n conventions:
+    - Root files: suffixed pattern (e.g., README_ZH.md)
+    - Sub-directories: subdir pattern (e.g., docs/guide/zh/xxx.md)
+
+    Returns a report of files missing translations in the checking target languages.
+    """
+    config = get_config()
+    target_root = Path(root).resolve() if root else Path(config.paths.root)
+    target_langs = config.i18n.target_langs
+    
+    console.print(f"Scanning i18n coverage in [bold cyan]{target_root}[/bold cyan]...")
+    console.print(f"Target Languages: [bold yellow]{', '.join(target_langs)}[/bold yellow] (Source: {config.i18n.source_lang})")
+    
+    all_files = core.discover_markdown_files(target_root)
+    
+    source_files = [f for f in all_files if not core.is_translation_file(f, target_langs)]
+    
+    # Store missing results: { file_path: [missing_langs] }
+    missing_map = {}
+    total_checks = len(source_files) * len(target_langs)
+    found_count = 0
+    
+    for f in source_files:
+        missing_langs = core.check_translation_exists(f, target_root, target_langs)
+        if missing_langs:
+            missing_map[f] = missing_langs
+            found_count += (len(target_langs) - len(missing_langs))
+        else:
+            found_count += len(target_langs)
+            
+    # Reporting
+    coverage = (found_count / total_checks * 100) if total_checks > 0 else 100
+    
+    # Sort missing_map by file path for stable output
+    sorted_missing = sorted(missing_map.items(), key=lambda x: str(x[0]))
+    
+    # Apply limit
+    total_missing_files = len(sorted_missing)
+    display_limit = limit if limit > 0 else total_missing_files
+    displayed_missing = sorted_missing[:display_limit]
+    
+    # Build table title with count info
+    table_title = "i18n Availability Report"
+    if total_missing_files > 0:
+        if display_limit < total_missing_files:
+            table_title = f"i18n Availability Report (Showing {display_limit} / {total_missing_files} missing files)"
+        else:
+            table_title = f"i18n Availability Report ({total_missing_files} missing files)"
+    
+    table = Table(title=table_title, box=None)
+    table.add_column("Source File", style="cyan", no_wrap=True, overflow="fold")
+    table.add_column("Missing Languages", style="red")
+    table.add_column("Expected Paths", style="dim", no_wrap=True, overflow="fold")
+    
+    for f, langs in displayed_missing:
+        rel_path = f.relative_to(target_root)
+        expected_paths = []
+        for lang in langs:
+            target = core.get_target_translation_path(f, target_root, lang)
+            expected_paths.append(str(target.relative_to(target_root)))
+            
+        table.add_row(
+            str(rel_path), 
+            ", ".join(langs),
+            "\n".join(expected_paths)
+        )
+        
+    console.print(table)
+    
+    # Show hint if output was truncated
+    if display_limit < total_missing_files:
+        console.print(f"\n[dim]💡 Tip: Use [bold]--limit 0[/bold] to show all {total_missing_files} missing files.[/dim]\n")
+    
+    # Calculate partial vs complete missing
+    partial_missing = sum(1 for _, langs in sorted_missing if len(langs) < len(target_langs))
+    complete_missing = total_missing_files - partial_missing
+    
+    status_color = "green" if coverage == 100 else "yellow"
+    if coverage < 50:
+        status_color = "red"
+    
+    summary_lines = [
+        f"Total Source Files: {len(source_files)}",
+        f"Target Languages: {len(target_langs)}",
+        f"Total Checks: {total_checks}",
+        f"Found Translations: {found_count}",
+        f"Missing Files: {total_missing_files}",
+    ]
+    
+    if total_missing_files > 0:
+        summary_lines.append(f"  - Partial Missing: {partial_missing}")
+        summary_lines.append(f"  - Complete Missing: {complete_missing}")
+    
+    summary_lines.append(f"Coverage: [{status_color}]{coverage:.1f}%[/{status_color}]")
+    
+    summary = "\n".join(summary_lines)
+    console.print(Panel(summary, title="I18N STATUS", expand=False))
+
+    if missing_map:
+        raise typer.Exit(code=1)