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

monoco/daemon/services.py

@@ -1,21 +1,18 @@
-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] = []
 
@@ -33,32 +30,28 @@ class Broadcaster:
     async def broadcast(self, event_type: str, payload: dict):
         if not self.subscribers:
             return
-        
-        message = {
-            "event": event_type,
-            "data": json.dumps(payload)
-        }
-        
+
+        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.")
 
 
 # Monitors moved to monoco.core.git and monoco.features.issue.monitor
 
-from watchdog.observers import Observer
-from watchdog.events import FileSystemEventHandler
-from monoco.core.config import MonocoConfig, get_config
 
 from monoco.core.workspace import MonocoProject, Workspace
 
+
 class ProjectContext:
     """
     Holds the runtime state for a single project.
     Now wraps the core MonocoProject primitive.
     """
+
     def __init__(self, project: MonocoProject, broadcaster: Broadcaster):
         self.project = project
         self.id = project.id
@@ -73,11 +66,13 @@ class ProjectContext:
     def stop(self):
         self.monitor.stop()
 
+
 class ProjectManager:
     """
     Discovers and manages multiple Monoco projects within a workspace.
     Uses core Workspace primitive for discovery.
     """
+
     def __init__(self, workspace_root: Path, broadcaster: Broadcaster):
         self.workspace_root = workspace_root
         self.broadcaster = broadcaster
@@ -89,7 +84,7 @@ class ProjectManager:
         """
         logger.info(f"Scanning workspace: {self.workspace_root}")
         workspace = Workspace.discover(self.workspace_root)
-        
+
         for project in workspace.projects:
             if project.id not in self.projects:
                 ctx = ProjectContext(project, self.broadcaster)
@@ -114,50 +109,54 @@ class ProjectManager:
                 "id": p.id,
                 "name": p.name,
                 "path": str(p.path),
-                "issues_path": str(p.issues_root)
+                "issues_path": str(p.issues_root),
             }
             for p in self.projects.values()
         ]
 
+
 from monoco.features.issue.monitor import IssueMonitor
 
+
 class ProjectContext:
     """
     Holds the runtime state for a single project.
     Now wraps the core MonocoProject primitive.
     """
+
     def __init__(self, project: MonocoProject, broadcaster: Broadcaster):
         self.project = project
         self.id = project.id
         self.name = project.name
         self.path = project.path
         self.issues_root = project.issues_root
-        
+
         async def on_upsert(issue_data: dict):
-            await broadcaster.broadcast("issue_upserted", {
-                "issue": issue_data,
-                "project_id": self.id
-            })
+            await broadcaster.broadcast(
+                "issue_upserted", {"issue": issue_data, "project_id": self.id}
+            )
 
         async def on_delete(issue_data: dict):
             # We skip broadcast here if it's part of a move?
-            # Actually, standard upsert/delete is fine, but we need a specialized event for MOVE 
+            # Actually, standard upsert/delete is fine, but we need a specialized event for MOVE
             # to help VS Code redirect without closing/reopening.
-            await broadcaster.broadcast("issue_deleted", {
-                "id": issue_data["id"],
-                "project_id": self.id
-            })
+            await broadcaster.broadcast(
+                "issue_deleted", {"id": issue_data["id"], "project_id": self.id}
+            )
 
         self.monitor = IssueMonitor(self.issues_root, on_upsert, on_delete)
 
     async def notify_move(self, old_path: str, new_path: str, issue_data: dict):
         """Explicitly notify frontend about a logical move (Physical path changed)."""
-        await self.broadcaster.broadcast("issue_moved", {
-            "old_path": old_path,
-            "new_path": new_path,
-            "issue": issue_data,
-            "project_id": self.id
-        })
+        await self.broadcaster.broadcast(
+            "issue_moved",
+            {
+                "old_path": old_path,
+                "new_path": new_path,
+                "issue": issue_data,
+                "project_id": self.id,
+            },
+        )
 
     async def start(self):
         await self.monitor.start()

monoco/daemon/stats.py

@@ -1,4 +1,4 @@
-from typing import List, Dict, Set, Optional
+from typing import List, Dict, Optional
 from datetime import datetime, timedelta
 from pathlib import Path
 from enum import Enum
@@ -6,11 +6,13 @@ 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
@@ -19,30 +21,32 @@ class ActivityItem(BaseModel):
     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
-    
+    activity_window = now - timedelta(days=3)  # Show activities from last 3 days
+
     activities: List[ActivityItem] = []
 
     for issue in issues:
@@ -50,7 +54,7 @@ def calculate_dashboard_stats(issues_root: Path) -> DashboardStats:
         # 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
@@ -58,7 +62,7 @@ def calculate_dashboard_stats(issues_root: Path) -> DashboardStats:
                 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
@@ -73,52 +77,67 @@ def calculate_dashboard_stats(issues_root: Path) -> DashboardStats:
         # --- 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"
-            ))
+            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"
-            ))
-            
+        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
-            
+            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"
-                ))
+                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
+        recent_activities=recent_activities,
     )

monoco/features/config/commands.py

@@ -1,8 +1,7 @@
 import typer
 import yaml
 import json
-from pathlib import Path
-from typing import Optional, Any, Annotated
+from typing import Any
 from rich.console import Console
 from rich.syntax import Syntax
 from pydantic import ValidationError
@@ -13,13 +12,13 @@ from monoco.core.config import (
     ConfigScope,
     load_raw_config,
     save_raw_config,
-    get_config_path
 )
 from monoco.core.output import AgentOutput, OutputManager
 
 app = typer.Typer(help="Manage Monoco configuration")
 console = Console()
 
+
 def _parse_value(value: str) -> Any:
     """Parse string value into appropriate type (bool, int, float, str)."""
     if value.lower() in ("true", "yes", "on"):
@@ -36,16 +35,19 @@ def _parse_value(value: str) -> Any:
         except ValueError:
             return value
 
+
 @app.command()
 def show(
-    output: str = typer.Option("yaml", "--output", "-o", help="Output format: yaml or json"),
+    output: str = typer.Option(
+        "yaml", "--output", "-o", help="Output format: yaml or json"
+    ),
     json_output: AgentOutput = False,
 ):
     """Show the currently active (merged) configuration."""
     config = get_config()
     # Pydantic v1/v2 compat: use dict() or model_dump()
     data = config.dict()
-    
+
     if OutputManager.is_agent_mode():
         OutputManager.print(data)
         return
@@ -57,6 +59,7 @@ def show(
         syntax = Syntax(yaml_str, "yaml")
         console.print(syntax)
 
+
 @app.command()
 def get(
     key: str = typer.Argument(..., help="Configuration key (e.g. project.name)"),
@@ -65,17 +68,17 @@ def get(
     """Get a specific configuration value."""
     config = get_config()
     data = config.dict()
-    
+
     parts = key.split(".")
     current = data
-    
+
     for part in parts:
         if isinstance(current, dict) and part in current:
             current = current[part]
         else:
             OutputManager.error(f"Key '{key}' not found.")
             raise typer.Exit(code=1)
-            
+
     if OutputManager.is_agent_mode():
         OutputManager.print({"key": key, "value": current})
     else:
@@ -87,36 +90,41 @@ def get(
         else:
             print(current)
 
+
 @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"),
-    global_scope: bool = typer.Option(False, "--global", "-g", help="Update global configuration"),
+    global_scope: bool = typer.Option(
+        False, "--global", "-g", help="Update global configuration"
+    ),
     json_output: AgentOutput = False,
 ):
     """Set a configuration value in specific scope (project by default)."""
     scope = ConfigScope.GLOBAL if global_scope else ConfigScope.PROJECT
-    
+
     # 1. Load Raw Config for the target scope
     raw_data = load_raw_config(scope)
-    
+
     # 2. Parse Key & Update Data
     parts = key.split(".")
     target = raw_data
-    
+
     # Context management for nested updates
     for i, part in enumerate(parts[:-1]):
         if part not in target:
             target[part] = {}
         target = target[part]
         if not isinstance(target, dict):
-            parent_key = ".".join(parts[:i+1])
-            OutputManager.error(f"Cannot set '{key}': '{parent_key}' is not a dictionary ({type(target)}).")
+            parent_key = ".".join(parts[: i + 1])
+            OutputManager.error(
+                f"Cannot set '{key}': '{parent_key}' is not a dictionary ({type(target)})."
+            )
             raise typer.Exit(code=1)
-            
+
     parsed_val = _parse_value(value)
     target[parts[-1]] = parsed_val
-    
+
     # 3. Validate against Schema
     # We simulate a full load by creating a temporary MonocoConfig with these overrides.
     # Note: This validation is "active" - we want to ensure the resulting config WOULD be valid.
@@ -134,18 +142,23 @@ def set_val(
 
     # 4. Save
     save_raw_config(scope, raw_data)
-    
+
     scope_display = "Global" if global_scope else "Project"
-    
+
     if OutputManager.is_agent_mode():
-        OutputManager.print({
-            "status": "updated",
-            "scope": scope_display.lower(),
-            "key": key,
-            "value": parsed_val
-        })
+        OutputManager.print(
+            {
+                "status": "updated",
+                "scope": scope_display.lower(),
+                "key": key,
+                "value": parsed_val,
+            }
+        )
     else:
-        console.print(f"[green]✓ Set {key} = {parsed_val} in {scope_display} config.[/green]")
+        console.print(
+            f"[green]✓ Set {key} = {parsed_val} in {scope_display} config.[/green]"
+        )
+
 
 if __name__ == "__main__":
     app()

monoco/features/i18n/adapter.py

@@ -3,6 +3,7 @@ from typing import Dict
 from monoco.core.feature import MonocoFeature, IntegrationData
 from monoco.features.i18n import core
 
+
 class I18nFeature(MonocoFeature):
     @property
     def name(self) -> str:
@@ -15,15 +16,13 @@ class I18nFeature(MonocoFeature):
         # Determine language from config, default to 'en'
         lang = config.get("i18n", {}).get("source_lang", "en")
         base_dir = Path(__file__).parent / "resources"
-        
+
         prompt_file = base_dir / lang / "AGENTS.md"
         if not prompt_file.exists():
             prompt_file = base_dir / "en" / "AGENTS.md"
-            
+
         content = ""
         if prompt_file.exists():
             content = prompt_file.read_text(encoding="utf-8").strip()
 
-        return IntegrationData(
-            system_prompts={"Documentation I18n": content}
-        )
+        return IntegrationData(system_prompts={"Documentation I18n": content})