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

monoco/cli/project.py

@@ -0,0 +1,79 @@
+import typer
+from pathlib import Path
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+import yaml
+import json
+import os
+
+from monoco.core.workspace import find_projects, is_project_root
+from monoco.core.config import get_config
+
+app = typer.Typer(help="Manage Monoco Projects")
+console = Console()
+
+@app.command("list")
+def list_projects(
+    json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
+    root: Optional[str] = typer.Option(None, "--root", help="Workspace root")
+):
+    """List all discovered projects in the workspace."""
+    cwd = Path(root).resolve() if root else Path.cwd()
+    projects = find_projects(cwd)
+    
+    if json_output:
+        data = [
+            {
+                "id": p.id,
+                "name": p.name,
+                "path": str(p.path),
+                "key": p.config.project.key if p.config.project else ""
+            }
+            for p in projects
+        ]
+        print(json.dumps(data))
+    else:
+        table = Table(title=f"Projects in {cwd}")
+        table.add_column("ID", style="cyan")
+        table.add_column("Name", style="magenta")
+        table.add_column("Key", style="green")
+        table.add_column("Path", style="dim")
+        
+        for p in projects:
+            path_str = str(p.path.relative_to(cwd)) if p.path.is_relative_to(cwd) else str(p.path)
+            if path_str == ".":
+                path_str = "(root)"
+            key = p.config.project.key if p.config.project else "N/A"
+            table.add_row(p.id, p.name, key, path_str)
+            
+        console.print(table)
+
+@app.command("init")
+def init_project(
+    name: str = typer.Option(..., "--name", "-n", help="Project Name"),
+    key: str = typer.Option(..., "--key", "-k", help="Project Key"),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing config")
+):
+    """Initialize a new project in the current directory."""
+    cwd = Path.cwd()
+    project_config_path = cwd / ".monoco" / "project.yaml"
+    
+    if project_config_path.exists() and not force:
+        console.print(f"[yellow]Project already initialized in {cwd}. Use --force to overwrite.[/yellow]")
+        raise typer.Exit(code=1)
+        
+    cwd.mkdir(parents=True, exist_ok=True)
+    (cwd / ".monoco").mkdir(exist_ok=True)
+    
+    config = {
+        "project": {
+            "name": name,
+            "key": key
+        }
+    }
+    
+    with open(project_config_path, "w") as f:
+        yaml.dump(config, f, default_flow_style=False)
+        
+    console.print(f"[green]Initialized project '{name}' ({key}) in {cwd}[/green]")

monoco/cli/workspace.py

@@ -0,0 +1,38 @@
+import typer
+from pathlib import Path
+from rich.console import Console
+import yaml
+import json
+
+app = typer.Typer(help="Manage Monoco Workspace")
+console = Console()
+
+@app.command("init")
+def init_workspace(
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing config")
+):
+    """Initialize a workspace environment in the current directory."""
+    cwd = Path.cwd()
+    workspace_config_path = cwd / ".monoco" / "workspace.yaml"
+    
+    if workspace_config_path.exists() and not force:
+        console.print(f"[yellow]Workspace already initialized in {cwd}. Use --force to overwrite.[/yellow]")
+        raise typer.Exit(code=1)
+
+    cwd.mkdir(parents=True, exist_ok=True)
+    (cwd / ".monoco").mkdir(exist_ok=True)
+    
+    # Default workspace config
+    config = {
+        "paths": {
+            "issues": "Issues", # Default
+            "spikes": ".references",
+            "specs": "SPECS"
+        }
+    }
+    
+    with open(workspace_config_path, "w") as f:
+        yaml.dump(config, f, default_flow_style=False)
+        
+    console.print(f"[green]Initialized workspace in {cwd}[/green]")
+

monoco/core/agent/state.py

@@ -62,56 +62,45 @@ class AgentStateManager:
         return self.refresh()
 
     def refresh(self) -> AgentState:
-        """Run the diagnostic script and update state file."""
+        """Run diagnostics on all integrations and update state."""
         logger.info("Refreshing agent state...")
         
-        # Locate the shell script
-        # Assuming monoco is installed as a package, we need to find where the script lives.
-        # For dev environment: Toolkit/scripts/check_agents.sh
-        # For production: It might need to be packaged or generated.
+        from monoco.core.integrations import get_all_integrations
+        from monoco.core.config import get_config
         
-        # Current strategy: Look in known relative locations
-        script_path = self._find_script()
-        if not script_path:
-            raise FileNotFoundError("Could not find check_agents.sh script")
-
-        try:
-            # Ensure the directory exists
-            self.state_path.parent.mkdir(parents=True, exist_ok=True)
+        # Load config to get possible overrides
+        # Determine root (hacky for now, should be passed)
+        root = Path.cwd()
+        config = get_config(str(root))
+        
+        integrations = get_all_integrations(config_overrides=config.agent.integrations, enabled_only=True)
+        
+        providers = {}
+        for key, integration in integrations.items():
+            if not integration.bin_name:
+                continue # Skip integrations that don't have a binary component
             
-            subprocess.run(
-                [str(script_path), str(self.state_path)], 
-                check=True, 
-                capture_output=True,
-                text=True
+            health = integration.check_health()
+            providers[key] = AgentProviderState(
+                available=health.available,
+                path=health.path,
+                error=health.error,
+                latency_ms=health.latency_ms
             )
             
-            # Reload to get the object
-            state = self.load()
-            if not state:
-                raise ValueError("Script ran but state file is invalid or empty")
-            
-            self._state = state
-            return state
+        state = AgentState(
+            last_checked=datetime.now(timezone.utc),
+            providers=providers
+        )
+        
+        # Save state
+        self.state_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.state_path, "w") as f:
+            yaml.dump(state.model_dump(mode='json'), f)
             
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Agent check script failed: {e.stderr}")
-            raise RuntimeError(f"Agent check failed: {e.stderr}") from e
+        self._state = state
+        return state
 
     def _find_script(self) -> Optional[Path]:
-        """Find the check_agents.sh script."""
-        # Check dev path relative to this file
-        # this file: monoco/core/agent/state.py
-        # root: monoco/../../
-        
-        current_file = Path(__file__).resolve()
-        
-        # Strategy 1: Development logic (Toolkit/scripts/check_agents.sh)
-        dev_path = current_file.parents[3] / "scripts" / "check_agents.sh"
-        if dev_path.exists():
-            return dev_path
-            
-        # Strategy 2: If installed in site-packages, maybe we package scripts nearby?
-        # TODO: Define packaging strategy for scripts
-        
+        """[Deprecated] No longer used."""
         return None

monoco/core/config.py

@@ -10,10 +10,7 @@ import asyncio
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
 
-# Import AgentIntegration for type hints
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    from monoco.core.integrations import AgentIntegration
+from monoco.core.integrations import AgentIntegration
 
 logger = logging.getLogger("monoco.core.config")
 
@@ -55,7 +52,7 @@ class AgentConfig(BaseModel):
     targets: Optional[list[str]] = Field(default=None, description="Specific target files to inject into (e.g. .cursorrules)")
     framework: Optional[str] = Field(default=None, description="Manually specified agent framework (cursor, windsurf, etc.)")
     includes: Optional[list[str]] = Field(default=None, description="List of specific features to include in injection")
-    integrations: Optional[Dict[str, Any]] = Field(
+    integrations: Optional[Dict[str, "AgentIntegration"]] = Field(
         default=None, 
         description="Custom agent framework integrations (overrides defaults from monoco.core.integrations)"
     )
@@ -84,9 +81,13 @@ class MonocoConfig(BaseModel):
         return base
 
     @classmethod
-    def load(cls, project_root: Optional[str] = None) -> "MonocoConfig":
+    def load(cls, project_root: Optional[str] = None, require_project: bool = False) -> "MonocoConfig":
         """
         Load configuration from multiple sources.
+        
+        Args:
+            project_root: Explicit root path. If None, uses CWD.
+            require_project: If True, raises error if .monoco directory is missing.
         """
         # 1. Start with empty dict (will use defaults via Pydantic)
         config_data = {}
@@ -96,12 +97,13 @@ class MonocoConfig(BaseModel):
         
         # Determine project path
         cwd = Path(project_root) if project_root else Path.cwd()
-        proj_path_hidden = cwd / ".monoco" / "config.yaml"
+        # FIX-0009: strict separation of workspace and project config
+        workspace_config_path = cwd / ".monoco" / "workspace.yaml"
+        project_config_path = cwd / ".monoco" / "project.yaml"
         
-        # [Legacy] Check for monoco.yaml and warn
-        proj_path_legacy = cwd / "monoco.yaml"
-        if proj_path_legacy.exists():
-            logger.warning(f"Legacy configuration found: {proj_path_legacy}. Please move it to .monoco/config.yaml")
+        # Strict Workspace Check
+        if require_project and not (cwd / ".monoco").exists():
+            raise FileNotFoundError(f"Monoco workspace not found in {cwd}. (No .monoco directory)")
 
         # 3. Load User Config
         if home_path.exists():
@@ -114,13 +116,35 @@ class MonocoConfig(BaseModel):
                 # We don't want to crash on config load fail, implementing simple warning equivalent
                 pass
 
-        # 4. Load Project Config (Only .monoco/config.yaml)
-        if proj_path_hidden.exists():
+        # 4. Load Project/Workspace Config
+        
+        # 4a. Load workspace.yaml (Global Environment)
+        if workspace_config_path.exists():
+            try:
+                with open(workspace_config_path, "r") as f:
+                    ws_config = yaml.safe_load(f)
+                    if ws_config:
+                        # workspace.yaml contains core, paths, i18n, ui, telemetry, agent
+                        cls._deep_merge(config_data, ws_config)
+            except Exception:
+                pass
+
+        # 4b. Load project.yaml (Identity)
+        if project_config_path.exists():
             try:
-                with open(proj_path_hidden, "r") as f:
-                    proj_config = yaml.safe_load(f)
-                    if proj_config:
-                        cls._deep_merge(config_data, proj_config)
+                with open(project_config_path, "r") as f:
+                    pj_config = yaml.safe_load(f)
+                    if pj_config:
+                        # project.yaml contains 'project' fields directly? or under 'project' key?
+                        # Design decision: project.yaml should be clean, e.g. "name: foo".
+                        # But to simplify merging, let's check if it has a 'project' key or is flat.
+                        if "project" in pj_config:
+                            cls._deep_merge(config_data, pj_config)
+                        else:
+                            # Assume flat structure mapping to 'project' section
+                            if "project" not in config_data:
+                                config_data["project"] = {}
+                            cls._deep_merge(config_data["project"], pj_config)
             except Exception:
                 pass
 
@@ -130,10 +154,12 @@ class MonocoConfig(BaseModel):
 # Global singleton
 _settings = None
 
-def get_config(project_root: Optional[str] = None) -> MonocoConfig:
+def get_config(project_root: Optional[str] = None, require_project: bool = False) -> MonocoConfig:
     global _settings
-    if _settings is None or project_root is not None:
-        _settings = MonocoConfig.load(project_root)
+    # If explicit root provided, always reload.
+    # If require_project is True, we must reload to ensure validation happens (in case a previous loose load occurred).
+    if _settings is None or project_root is not None or require_project:
+        _settings = MonocoConfig.load(project_root, require_project=require_project)
     return _settings
 
 class ConfigScope(str, Enum):

monoco/core/integrations.py

@@ -22,14 +22,59 @@ class AgentIntegration(BaseModel):
         name: Human-readable name of the framework
         system_prompt_file: Path to the system prompt/rules file relative to project root
         skill_root_dir: Path to the skills directory relative to project root
+        bin_name: Optional name of the binary to check for (e.g., 'cursor', 'gemini')
+        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")
+    version_cmd: Optional[str] = Field(None, description="Command to check version")
     enabled: bool = Field(default=True, description="Whether this integration is active")
 
+    def check_health(self) -> "AgentProviderHealth":
+        """
+        Check health of this integration.
+        """
+        import shutil
+        import subprocess
+        import time
+
+        if not self.bin_name:
+            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")
+
+        if not self.version_cmd:
+             return AgentProviderHealth(available=True, path=bin_path)
+
+        start_time = time.time()
+        try:
+            # We use a shortcut to check version cmd
+            # Some tools might need e.g. 'cursor --version'
+            subprocess.run(
+                [self.bin_name] + self.version_cmd.split(),
+                check=True,
+                capture_output=True,
+                timeout=5
+            )
+            latency = int((time.time() - start_time) * 1000)
+            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
+    latency_ms: Optional[int] = None
+
 
 # Default Integration Registry
 DEFAULT_INTEGRATIONS: Dict[str, AgentIntegration] = {
@@ -38,24 +83,32 @@ DEFAULT_INTEGRATIONS: Dict[str, AgentIntegration] = {
         name="Cursor",
         system_prompt_file=".cursorrules",
         skill_root_dir=".cursor/skills/",
+        bin_name="cursor",
+        version_cmd="--version",
     ),
     "claude": AgentIntegration(
         key="claude",
         name="Claude Code",
         system_prompt_file="CLAUDE.md",
         skill_root_dir=".claude/skills/",
+        bin_name="claude",
+        version_cmd="--version",
     ),
     "gemini": AgentIntegration(
         key="gemini",
         name="Gemini CLI",
         system_prompt_file="GEMINI.md",
         skill_root_dir=".gemini/skills/",
+        bin_name="gemini",
+        version_cmd="--version",
     ),
     "qwen": AgentIntegration(
         key="qwen",
         name="Qwen Code",
         system_prompt_file="QWEN.md",
         skill_root_dir=".qwen/skills/",
+        bin_name="qwen",
+        version_cmd="--version",
     ),
     "agent": AgentIntegration(
         key="agent",

monoco/core/lsp.py

@@ -0,0 +1,61 @@
+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
+
+    def __lt__(self, other):
+        if self.line != other.line:
+            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 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
+    source: Optional[str] = "monoco"
+    message: str
+    related_information: Optional[List[DiagnosticRelatedInformation]] = None
+    data: Optional[dict] = None  # To carry extra info (e.g. for code actions)
+
+    def to_user_string(self) -> str:
+        """Helper to format for CLI output"""
+        severity_map = {
+            1: "[red]Error[/red]",
+            2: "[yellow]Warning[/yellow]",
+            3: "[blue]Info[/blue]",
+            4: "[dim]Hint[/dim]"
+        }
+        sev = severity_map.get(self.severity, "Error")
+        return f"{sev}: {self.message} (Line {self.range.start.line + 1})"