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

monoco/core/integrations.py

@@ -16,7 +16,7 @@ from pydantic import BaseModel, Field
 class AgentIntegration(BaseModel):
     """
     Configuration for a single agent framework integration.
-    
+
     Attributes:
         key: Unique identifier for the framework (e.g., 'cursor', 'gemini')
         name: Human-readable name of the framework
@@ -26,13 +26,22 @@ class AgentIntegration(BaseModel):
         version_cmd: Optional command to check version (e.g., '--version')
         enabled: Whether this integration is active (default: True)
     """
+
     key: str = Field(..., description="Unique framework identifier")
     name: str = Field(..., description="Human-readable framework name")
-    system_prompt_file: str = Field(..., description="Path to system prompt file (relative to project root)")
-    skill_root_dir: str = Field(..., description="Path to skills directory (relative to project root)")
-    bin_name: Optional[str] = Field(None, description="Binary name to check for availability")
+    system_prompt_file: str = Field(
+        ..., description="Path to system prompt file (relative to project root)"
+    )
+    skill_root_dir: str = Field(
+        ..., description="Path to skills directory (relative to project root)"
+    )
+    bin_name: Optional[str] = Field(
+        None, description="Binary name to check for availability"
+    )
     version_cmd: Optional[str] = Field(None, description="Command to check version")
-    enabled: bool = Field(default=True, description="Whether this integration is active")
+    enabled: bool = Field(
+        default=True, description="Whether this integration is active"
+    )
 
     def check_health(self) -> "AgentProviderHealth":
         """
@@ -43,14 +52,18 @@ class AgentIntegration(BaseModel):
         import time
 
         if not self.bin_name:
-            return AgentProviderHealth(available=True) # If no binary required, assume ok
+            return AgentProviderHealth(
+                available=True
+            )  # If no binary required, assume ok
 
         bin_path = shutil.which(self.bin_name)
         if not bin_path:
-            return AgentProviderHealth(available=False, error=f"Binary '{self.bin_name}' not found in PATH")
+            return AgentProviderHealth(
+                available=False, error=f"Binary '{self.bin_name}' not found in PATH"
+            )
 
         if not self.version_cmd:
-             return AgentProviderHealth(available=True, path=bin_path)
+            return AgentProviderHealth(available=True, path=bin_path)
 
         start_time = time.time()
         try:
@@ -60,16 +73,19 @@ class AgentIntegration(BaseModel):
                 [self.bin_name] + self.version_cmd.split(),
                 check=True,
                 capture_output=True,
-                timeout=5
+                timeout=5,
             )
             latency = int((time.time() - start_time) * 1000)
-            return AgentProviderHealth(available=True, path=bin_path, latency_ms=latency)
+            return AgentProviderHealth(
+                available=True, path=bin_path, latency_ms=latency
+            )
         except Exception as e:
             return AgentProviderHealth(available=False, path=bin_path, error=str(e))
 
 
 class AgentProviderHealth(BaseModel):
     """Health check result for an agent provider."""
+
     available: bool
     path: Optional[str] = None
     error: Optional[str] = None
@@ -128,19 +144,18 @@ DEFAULT_INTEGRATIONS: Dict[str, AgentIntegration] = {
 
 
 def get_integration(
-    name: str,
-    config_overrides: Optional[Dict[str, AgentIntegration]] = None
+    name: str, config_overrides: Optional[Dict[str, AgentIntegration]] = None
 ) -> Optional[AgentIntegration]:
     """
     Get an agent integration by name.
-    
+
     Args:
         name: The framework key (e.g., 'cursor', 'gemini')
         config_overrides: Optional user-defined integrations from config
-        
+
     Returns:
         AgentIntegration if found, None otherwise
-        
+
     Priority:
         1. User config overrides
         2. Default registry
@@ -148,52 +163,52 @@ def get_integration(
     # Check user overrides first
     if config_overrides and name in config_overrides:
         return config_overrides[name]
-    
+
     # Fall back to defaults
     return DEFAULT_INTEGRATIONS.get(name)
 
 
 def get_all_integrations(
     config_overrides: Optional[Dict[str, AgentIntegration]] = None,
-    enabled_only: bool = True
+    enabled_only: bool = True,
 ) -> Dict[str, AgentIntegration]:
     """
     Get all available integrations.
-    
+
     Args:
         config_overrides: Optional user-defined integrations from config
         enabled_only: If True, only return enabled integrations
-        
+
     Returns:
         Dictionary of all integrations (merged defaults + overrides)
     """
     # Start with defaults
     all_integrations = DEFAULT_INTEGRATIONS.copy()
-    
+
     # Merge user overrides
     if config_overrides:
         all_integrations.update(config_overrides)
-    
+
     # Filter by enabled status if requested
     if enabled_only:
         return {k: v for k, v in all_integrations.items() if v.enabled}
-    
+
     return all_integrations
 
 
 def detect_frameworks(root: Path) -> List[str]:
     """
     Auto-detect which agent frameworks are present in the project.
-    
+
     Detection is based on the existence of characteristic files/directories
     for each framework.
-    
+
     Args:
         root: Project root directory
-        
+
     Returns:
         List of detected framework keys (e.g., ['cursor', 'gemini'])
-        
+
     Example:
         >>> root = Path("/path/to/project")
         >>> frameworks = detect_frameworks(root)
@@ -201,42 +216,42 @@ def detect_frameworks(root: Path) -> List[str]:
         ['cursor', 'gemini']
     """
     detected = []
-    
+
     for key, integration in DEFAULT_INTEGRATIONS.items():
         # Check if system prompt file exists
         prompt_file = root / integration.system_prompt_file
-        
+
         # Check if skill directory exists
         skill_dir = root / integration.skill_root_dir
-        
+
         # Consider framework present if either exists
         if prompt_file.exists() or skill_dir.exists():
             detected.append(key)
-    
+
     return detected
 
 
 def get_active_integrations(
     root: Path,
     config_overrides: Optional[Dict[str, AgentIntegration]] = None,
-    auto_detect: bool = True
+    auto_detect: bool = True,
 ) -> Dict[str, AgentIntegration]:
     """
     Get integrations that are both enabled and detected in the project.
-    
+
     Args:
         root: Project root directory
         config_overrides: Optional user-defined integrations from config
         auto_detect: If True, only return integrations detected in the project
-        
+
     Returns:
         Dictionary of active integrations
     """
     all_integrations = get_all_integrations(config_overrides, enabled_only=True)
-    
+
     if not auto_detect:
         return all_integrations
-    
+
     # Filter by detection
     detected_keys = detect_frameworks(root)
     return {k: v for k, v in all_integrations.items() if k in detected_keys}

monoco/core/lsp.py

@@ -2,10 +2,12 @@ from enum import IntEnum
 from typing import List, Optional, Union
 from pydantic import BaseModel
 
+
 class Position(BaseModel):
     """
     Position in a text document expressed as zero-based line and character offset.
     """
+
     line: int
     character: int
 
@@ -14,40 +16,49 @@ class Position(BaseModel):
             return self.line < other.line
         return self.character < other.character
 
+
 class Range(BaseModel):
     """
     A range in a text document expressed as (zero-based) start and end positions.
     """
+
     start: Position
     end: Position
 
     def __repr__(self):
         return f"{self.start.line}:{self.start.character}-{self.end.line}:{self.end.character}"
 
+
 class Location(BaseModel):
     """
     Represents a location inside a resource, such as a line of code inside a text file.
     """
+
     uri: str
     range: Range
 
+
 class DiagnosticSeverity(IntEnum):
     Error = 1
     Warning = 2
     Information = 3
     Hint = 4
 
+
 class DiagnosticRelatedInformation(BaseModel):
     """
     Represents a related message and source code location for a diagnostic.
     """
+
     # location: Location  # Defined elsewhere or simplified here
     message: str
 
+
 class Diagnostic(BaseModel):
     """
     Represents a diagnostic, such as a compiler error or warning.
     """
+
     range: Range
     severity: Optional[DiagnosticSeverity] = None
     code: Optional[Union[int, str]] = None
@@ -62,7 +73,7 @@ class Diagnostic(BaseModel):
             1: "[red]Error[/red]",
             2: "[yellow]Warning[/yellow]",
             3: "[blue]Info[/blue]",
-            4: "[dim]Hint[/dim]"
+            4: "[dim]Hint[/dim]",
         }
         sev = severity_map.get(self.severity, "Error")
         return f"{sev}: {self.message} (Line {self.range.start.line + 1})"

monoco/core/output.py

@@ -7,12 +7,20 @@ from rich.console import Console
 from rich.table import Table
 from rich import print as rprint
 
+
 def _set_agent_mode(value: bool):
     if value:
         os.environ["AGENT_FLAG"] = "true"
 
+
 # Reusable dependency for commands
-AgentOutput = Annotated[bool, typer.Option("--json", help="Output in compact JSON for Agents", callback=_set_agent_mode)]
+AgentOutput = Annotated[
+    bool,
+    typer.Option(
+        "--json", help="Output in compact JSON for Agents", callback=_set_agent_mode
+    ),
+]
+
 
 class OutputManager:
     """
@@ -27,11 +35,14 @@ class OutputManager:
             1. Environment variable AGENT_FLAG=true (or 1)
             2. Environment variable MONOCO_AGENT=true (or 1)
         """
-        return os.getenv("AGENT_FLAG", "").lower() in ("true", "1") or \
-               os.getenv("MONOCO_AGENT", "").lower() in ("true", "1")
+        return os.getenv("AGENT_FLAG", "").lower() in ("true", "1") or os.getenv(
+            "MONOCO_AGENT", ""
+        ).lower() in ("true", "1")
 
     @staticmethod
-    def print(data: Union[BaseModel, List[BaseModel], dict, list, str], title: str = ""):
+    def print(
+        data: Union[BaseModel, List[BaseModel], dict, list, str], title: str = ""
+    ):
         """
         Dual frontend dispatcher.
         """
@@ -58,20 +69,27 @@ class OutputManager:
         """
         if isinstance(data, BaseModel):
             print(data.model_dump_json(exclude_none=True))
-        elif isinstance(data, list) and all(isinstance(item, BaseModel) for item in data):
+        elif isinstance(data, list) and all(
+            isinstance(item, BaseModel) for item in data
+        ):
             # Pydantic v2 adapter for list of models
-            print(json.dumps([item.model_dump(mode='json', exclude_none=True) for item in data], separators=(',', ':')))
+            print(
+                json.dumps(
+                    [item.model_dump(mode="json", exclude_none=True) for item in data],
+                    separators=(",", ":"),
+                )
+            )
         else:
             # Fallback for dicts/lists/primitives
             def _encoder(obj):
                 if isinstance(obj, BaseModel):
-                    return obj.model_dump(mode='json', exclude_none=True)
-                if hasattr(obj, 'value'): # Enum support
-                     return obj.value
+                    return obj.model_dump(mode="json", exclude_none=True)
+                if hasattr(obj, "value"):  # Enum support
+                    return obj.value
                 return str(obj)
 
             try:
-                print(json.dumps(data, separators=(',', ':'), default=_encoder))
+                print(json.dumps(data, separators=(",", ":"), default=_encoder))
             except TypeError:
                 print(str(data))
 
@@ -81,7 +99,7 @@ class OutputManager:
         Human channel: Visual priority.
         """
         console = Console()
-        
+
         if title:
             console.rule(f"[bold blue]{title}[/bold blue]")
 
@@ -92,24 +110,25 @@ class OutputManager:
         # Special handling for Lists of Pydantic Models -> Table
         if isinstance(data, list) and data and isinstance(data[0], BaseModel):
             table = Table(show_header=True, header_style="bold magenta")
-            
+
             # Introspect fields from the first item
             model_type = type(data[0])
             fields = model_type.model_fields.keys()
-            
+
             for field in fields:
                 table.add_column(field.replace("_", " ").title())
-            
+
             for item in data:
                 row = [str(getattr(item, field)) for field in fields]
                 table.add_row(*row)
-            
+
             console.print(table)
             return
-            
+
         # Fallback to rich pretty print
         rprint(data)
 
+
 # Global helper
 print_output = OutputManager.print
 print_error = OutputManager.error

monoco/core/registry.py

@@ -1,6 +1,7 @@
-from typing import Dict, List, Type
+from typing import Dict, List
 from monoco.core.feature import MonocoFeature
 
+
 class FeatureRegistry:
     _features: Dict[str, MonocoFeature] = {}
 
@@ -29,7 +30,7 @@ class FeatureRegistry:
         from monoco.features.issue.adapter import IssueFeature
         from monoco.features.spike.adapter import SpikeFeature
         from monoco.features.i18n.adapter import I18nFeature
-        
+
         cls.register(IssueFeature())
         cls.register(SpikeFeature())
         cls.register(I18nFeature())