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

monoco/cli/project.py

@@ -1,6 +1,6 @@
 import typer
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Annotated
 from rich.console import Console
 from rich.table import Table
 import yaml
@@ -9,20 +9,21 @@ import os
 
 from monoco.core.workspace import find_projects, is_project_root
 from monoco.core.config import get_config
+from monoco.core.output import AgentOutput, OutputManager
 
 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"),
+    json: AgentOutput = False,
     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:
+    if OutputManager.is_agent_mode():
         data = [
             {
                 "id": p.id,
@@ -32,7 +33,7 @@ def list_projects(
             }
             for p in projects
         ]
-        print(json.dumps(data))
+        OutputManager.print(data)
     else:
         table = Table(title=f"Projects in {cwd}")
         table.add_column("ID", style="cyan")
@@ -53,14 +54,15 @@ def list_projects(
 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")
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing config"),
+    json: AgentOutput = False,
 ):
     """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]")
+        OutputManager.error(f"Project already initialized in {cwd}. Use --force to overwrite.")
         raise typer.Exit(code=1)
         
     cwd.mkdir(parents=True, exist_ok=True)
@@ -76,4 +78,10 @@ def init_project(
     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]")
+    OutputManager.print({
+        "status": "initialized",
+        "name": name,
+        "key": key,
+        "path": str(cwd),
+        "config_file": str(project_config_path)
+    })

monoco/cli/workspace.py

@@ -1,22 +1,26 @@
 import typer
 from pathlib import Path
 from rich.console import Console
+from typing import Annotated
 import yaml
 import json
 
+from monoco.core.output import AgentOutput, OutputManager
+
 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")
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing config"),
+    json: AgentOutput = False,
 ):
     """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]")
+        OutputManager.error(f"Workspace already initialized in {cwd}. Use --force to overwrite.")
         raise typer.Exit(code=1)
 
     cwd.mkdir(parents=True, exist_ok=True)
@@ -34,5 +38,9 @@ def init_workspace(
     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]")
+    OutputManager.print({
+        "status": "initialized",
+        "path": str(cwd),
+        "config_file": str(workspace_config_path)
+    })
 

monoco/core/agent/adapters.py

@@ -21,6 +21,16 @@ class BaseCLIClient:
 
     def _build_prompt(self, prompt: str, context_files: List[Path]) -> str:
         """Concatenate prompt and context files."""
+        # Inject Language Rule
+        try:
+            from monoco.core.config import get_config
+            settings = get_config()
+            lang = settings.i18n.source_lang
+            if lang:
+                 prompt = f"{prompt}\n\n[SYSTEM: LANGUAGE CONSTRAINT]\nThe project source language is '{lang}'. You MUST use '{lang}' for all thinking and reporting unless explicitly instructed otherwise."
+        except Exception:
+            pass
+
         full_prompt = [prompt]
         if context_files:
             full_prompt.append("\n\n--- CONTEXT FILES ---")
@@ -93,10 +103,23 @@ class QwenClient(BaseCLIClient, AgentClient):
         return await self._run_command([self._executable, full_prompt])
 
 
+class KimiClient(BaseCLIClient, AgentClient):
+    """Adapter for Moonshot Kimi CLI."""
+    
+    def __init__(self):
+        super().__init__("kimi")
+
+    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
+        full_prompt = self._build_prompt(prompt, context_files)
+        # Usage: kimi "prompt"
+        return await self._run_command([self._executable, full_prompt])
+
+
 _ADAPTERS = {
     "gemini": GeminiClient,
     "claude": ClaudeClient,
-    "qwen": QwenClient
+    "qwen": QwenClient,
+    "kimi": KimiClient
 }
 
 def get_agent_client(name: str) -> AgentClient:

monoco/core/config.py

@@ -1,7 +1,7 @@
 import os
 import yaml
 from pathlib import Path
-from typing import Optional, Dict, Any, Callable, Awaitable
+from typing import Optional, Dict, Any, Callable, Awaitable, List
 from enum import Enum
 from pydantic import BaseModel, Field
 
@@ -23,7 +23,6 @@ class PathsConfig(BaseModel):
 
 class CoreConfig(BaseModel):
     """Core system configuration."""
-    editor: str = Field(default_factory=lambda: os.getenv("EDITOR", "vim"), description="Preferred text editor")
     log_level: str = Field(default="INFO", description="Logging verbosity")
     author: Optional[str] = Field(default=None, description="Default author for new artifacts")
 
@@ -57,6 +56,67 @@ class AgentConfig(BaseModel):
         description="Custom agent framework integrations (overrides defaults from monoco.core.integrations)"
     )
 
+class IssueTypeConfig(BaseModel):
+    name: str
+    label: str
+    prefix: str
+    folder: str
+    description: Optional[str] = None
+
+class TransitionConfig(BaseModel):
+    name: str
+    label: str
+    icon: Optional[str] = None
+    from_status: Optional[str] = None
+    from_stage: Optional[str] = None
+    to_status: str
+    to_stage: Optional[str] = None
+    required_solution: Optional[str] = None
+    description: str = ""
+    command_template: Optional[str] = None
+
+class IssueSchemaConfig(BaseModel):
+    types: List[IssueTypeConfig] = Field(default_factory=list)
+    statuses: List[str] = Field(default_factory=list)
+    stages: List[str] = Field(default_factory=list)
+    solutions: List[str] = Field(default_factory=list)
+    workflows: List[TransitionConfig] = Field(default_factory=list)
+
+    def merge(self, other: "IssueSchemaConfig") -> "IssueSchemaConfig":
+        if not other:
+            return self
+        
+        # Types: merge by name
+        if other.types:
+            type_map = {t.name: t for t in self.types}
+            for ot in other.types:
+                type_map[ot.name] = ot
+            self.types = list(type_map.values())
+        
+        # Statuses: replace if provided
+        if other.statuses:
+            self.statuses = other.statuses
+        
+        # Stages: replace if provided
+        if other.stages:
+            self.stages = other.stages
+            
+        # Solutions: replace if provided
+        if other.solutions:
+            self.solutions = other.solutions
+            
+        # Workflows (Transitions): merge by name
+        if other.workflows:
+            wf_map = {w.name: w for w in self.workflows}
+            for ow in other.workflows:
+                wf_map[ow.name] = ow
+            self.workflows = list(wf_map.values())
+                
+        return self
+
+class StateMachineConfig(BaseModel):
+    transitions: List[TransitionConfig]
+
 class MonocoConfig(BaseModel):
     """
     Main Configuration Schema.
@@ -69,6 +129,7 @@ class MonocoConfig(BaseModel):
     ui: UIConfig = Field(default_factory=UIConfig)
     telemetry: TelemetryConfig = Field(default_factory=TelemetryConfig)
     agent: AgentConfig = Field(default_factory=AgentConfig)
+    issue: IssueSchemaConfig = Field(default_factory=IssueSchemaConfig)
 
     @staticmethod
     def _deep_merge(base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:
@@ -165,14 +226,31 @@ def get_config(project_root: Optional[str] = None, require_project: bool = False
 class ConfigScope(str, Enum):
     GLOBAL = "global"
     PROJECT = "project"
+    WORKSPACE = "workspace"
 
 def get_config_path(scope: ConfigScope, project_root: Optional[str] = None) -> Path:
     """Get the path to the configuration file for a given scope."""
     if scope == ConfigScope.GLOBAL:
         return Path.home() / ".monoco" / "config.yaml"
+    elif scope == ConfigScope.WORKSPACE:
+        cwd = Path(project_root) if project_root else Path.cwd()
+        return cwd / ".monoco" / "workspace.yaml"
     else:
+        # ConfigScope.PROJECT
         cwd = Path(project_root) if project_root else Path.cwd()
-        return cwd / ".monoco" / "config.yaml"
+        return cwd / ".monoco" / "project.yaml"
+
+def find_monoco_root(start_path: Optional[Path] = None) -> Path:
+    """Recursively find the .monoco directory upwards."""
+    current = (start_path or Path.cwd()).resolve()
+    # Check if we are inside a .monoco folder (unlikely but possible)
+    if current.name == ".monoco":
+        return current.parent
+        
+    for parent in [current] + list(current.parents):
+        if (parent / ".monoco").exists():
+            return parent
+    return current
 
 def load_raw_config(scope: ConfigScope, project_root: Optional[str] = None) -> Dict[str, Any]:
     """Load raw configuration dictionary from a specific scope."""

monoco/core/integrations.py

@@ -110,6 +110,14 @@ DEFAULT_INTEGRATIONS: Dict[str, AgentIntegration] = {
         bin_name="qwen",
         version_cmd="--version",
     ),
+    "kimi": AgentIntegration(
+        key="kimi",
+        name="Kimi CLI",
+        system_prompt_file="KIMI.md",
+        skill_root_dir=".kimi/skills/",
+        bin_name="kimi",
+        version_cmd="--version",
+    ),
     "agent": AgentIntegration(
         key="agent",
         name="Antigravity",

monoco/core/lsp.py

@@ -24,6 +24,13 @@ class Range(BaseModel):
     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

monoco/core/output.py

@@ -63,8 +63,15 @@ class OutputManager:
             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 str(obj)
+
             try:
-                print(json.dumps(data, separators=(',', ':'), default=str))
+                print(json.dumps(data, separators=(',', ':'), default=_encoder))
             except TypeError:
                 print(str(data))
 

monoco/core/resources/en/SKILL.md

@@ -52,7 +52,7 @@ Configuration is stored in YAML format at:
 
 Key configuration sections:
 
-- `core`: Editor, log level, author
+- `core`: Log level, author
 - `paths`: Directory paths (issues, spikes, specs)
 - `project`: Project metadata, spike repos, workspace members
 - `i18n`: Internationalization settings

monoco/core/setup.py

@@ -162,7 +162,6 @@ def init_cli(
             user_config = {
                 "core": {
                     "author": author,
-                    # Editor is handled by env/config defaults, no need to prompt
                 },
                 "telemetry": {
                     "enabled": telemetry
@@ -259,6 +258,14 @@ def init_cli(
     (cwd / "Issues").mkdir(exist_ok=True)
     (cwd / ".references").mkdir(exist_ok=True)
     
+    # Initialize Agent Resources
+    try:
+        from monoco.features.agent.core import init_agent_resources
+        init_agent_resources(cwd)
+        console.print(f"[dim]  - Agent Resources: .monoco/actions/*.prompty[/dim]")
+    except Exception as e:
+        console.print(f"[yellow]Warning: Failed to init agent resources: {e}[/yellow]")
+
     console.print("\n[bold green]✓ Monoco Project Initialized![/bold green]")
     console.print(f"Access configured! issues will be created as [bold]{project_key}-XXX[/bold]")
 

monoco/daemon/app.py

@@ -9,7 +9,6 @@ from typing import Optional, List, Dict
 from monoco.daemon.services import Broadcaster, ProjectManager
 from monoco.core.git import GitMonitor
 from monoco.core.config import get_config, ConfigMonitor, ConfigScope, get_config_path
-from fastapi import FastAPI, Request, HTTPException, Query
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -29,7 +28,7 @@ Monoco Daemon Process
 # Service Instances
 broadcaster = Broadcaster()
 git_monitor: GitMonitor | None = None
-config_monitor: ConfigMonitor | None = None
+config_monitors: List[ConfigMonitor] = []
 project_manager: ProjectManager | None = None
 
 @asynccontextmanager
@@ -37,7 +36,7 @@ async def lifespan(app: FastAPI):
     # Startup
     logger.info("Starting Monoco Daemon services...")
     
-    global project_manager, git_monitor, config_monitor
+    global project_manager, git_monitor, config_monitors
     # Use MONOCO_SERVER_ROOT if set, otherwise CWD
     env_root = os.getenv("MONOCO_SERVER_ROOT")
     workspace_root = Path(env_root) if env_root else Path.cwd()
@@ -50,32 +49,39 @@ async def lifespan(app: FastAPI):
             "hash": new_hash
         })
     
-    async def on_config_change():
-        logger.info("Config file changed, broadcasting update...")
+    async def on_config_change(path: str):
+        logger.info(f"Config file changed: {path}, broadcasting update...")
         await broadcaster.broadcast("CONFIG_UPDATED", {
             "scope": "workspace",
-            "path": str(workspace_root / ".monoco" / "config.yaml")
+            "path": path
         })
 
     git_monitor = GitMonitor(workspace_root, on_git_change)
     
-    config_path = get_config_path(ConfigScope.PROJECT, workspace_root)
-    config_monitor = ConfigMonitor(config_path, on_config_change)
+    project_config_path = get_config_path(ConfigScope.PROJECT, str(workspace_root))
+    workspace_config_path = get_config_path(ConfigScope.WORKSPACE, str(workspace_root))
+    
+    config_monitors = [
+        ConfigMonitor(project_config_path, lambda: on_config_change(str(project_config_path))),
+        ConfigMonitor(workspace_config_path, lambda: on_config_change(str(workspace_config_path)))
+    ]
     
     await project_manager.start_all()
     git_task = asyncio.create_task(git_monitor.start())
-    config_task = asyncio.create_task(config_monitor.start())
+    config_tasks = [asyncio.create_task(m.start()) for m in config_monitors]
     
     yield
     # Shutdown
     logger.info("Shutting down Monoco Daemon services...")
     if git_monitor:
         git_monitor.stop()
-    if config_monitor:
-        config_monitor.stop()
+    for m in config_monitors:
+        m.stop()
     if project_manager:
         project_manager.stop_all()
-    await asyncio.gather(git_task, config_task)
+    
+    await git_task
+    await asyncio.gather(*config_tasks)
     
 app = FastAPI(
     title="Monoco Daemon",

monoco/features/agent/commands.py

@@ -1,8 +1,8 @@
 
 import typer
-from typing import Optional
+from typing import Optional, Annotated
 from pathlib import Path
-from monoco.core.output import print_output, print_error
+from monoco.core.output import print_output, print_error, AgentOutput, OutputManager
 from monoco.core.agent.adapters import get_agent_client
 from monoco.core.agent.state import AgentStateManager
 from monoco.core.agent.action import ActionRegistry, ActionContext
@@ -12,6 +12,8 @@ import re
 import json as j
 
 app = typer.Typer()
+action_app = typer.Typer(name="action", help="Manage generic agent actions/prompts.")
+app.add_typer(action_app)
 
 @app.command(name="run")
 def run_command(
@@ -19,6 +21,7 @@ def run_command(
     target: Optional[str] = typer.Argument(None, help="Target file argument for the task"),
     provider: Optional[str] = typer.Option(None, "--using", "-u", help="Override agent provider"),
     instruction: Optional[str] = typer.Option(None, "--instruction", "-i", help="Additional instruction for the agent"),
+    json: AgentOutput = False,
 ):
     """
     Execute a prompt or a named task using an Agent CLI.
@@ -39,7 +42,8 @@ def run_command(
     
     if action:
         # It IS an action
-        print(f"Running action: {action.name}")
+        if not OutputManager.is_agent_mode():
+            print(f"Running action: {action.name}")
         
         # Simple template substitution
         final_prompt = action.template
@@ -72,7 +76,8 @@ def run_command(
     # 3. State Check
     state = state_manager.load()
     if not state or state.is_stale:
-        print("Agent state stale or missing, refreshing...")
+        if not OutputManager.is_agent_mode():
+            print("Agent state stale or missing, refreshing...")
         state = state_manager.refresh()
     
     if prov_name not in state.providers:
@@ -87,15 +92,19 @@ def run_command(
     try:
         client = get_agent_client(prov_name)
         result = asyncio.run(client.execute(final_prompt, context_files=context_files))
-        print(result)
+        
+        if OutputManager.is_agent_mode():
+            OutputManager.print({"result": result, "provider": prov_name})
+        else:
+            print(result)
         
     except Exception as e:
         print_error(f"Execution failed: {e}")
         raise typer.Exit(1)
 
-@app.command()
-def list(
-    json: bool = typer.Option(False, "--json", help="Output in JSON format"),
+@action_app.command(name="list")
+def action_list(
+    json: AgentOutput = False,
     context: Optional[str] = typer.Option(None, "--context", help="Context for filtering (JSON string)")
 ):
     """List available actions."""
@@ -111,29 +120,78 @@ def list(
             print_error(f"Invalid context JSON: {e}")
 
     actions = registry.list_available(action_context)
-    if json:
-        print(j.dumps([a.dict() for a in actions], indent=2))
-    else:
-        print_output(actions, title="Available Actions")
+    
+    # Filter by State Machine if context implies an Issue
+    if action_context and (action_context.status or action_context.stage):
+        try:
+            from monoco.features.issue.engine.machine import StateMachine
+            from monoco.features.issue.models import IssueMetadata
+            
+            cfg = settings.issue
+            sm = StateMachine(cfg)
+            
+            # Create a mock metadata for state check
+            mock_meta = IssueMetadata(
+                id="mock-id",
+                title="Mock Issue",
+                type=action_context.type or "feature",
+                status=action_context.status or "open",
+                stage=action_context.stage
+            )
+            
+            allowed_transitions = sm.get_available_transitions(mock_meta)
+            allowed_names = {t.name for t in allowed_transitions}
+            
+            # Identify which actions are actually transitions
+            all_transition_names = {t.name for t in cfg.workflows}
+            
+            filtered_actions = []
+            for action in actions:
+                # If an action is a formal transition, it must be allowed
+                if action.name in all_transition_names:
+                    if action.name in allowed_names:
+                        filtered_actions.append(action)
+                else:
+                    # Generic actions are passed through (already filtered by 'when')
+                    filtered_actions.append(action)
+            
+            actions = filtered_actions
+
+        except Exception:
+            # Fallback if Issue feature is missing or context is invalid
+            pass
+
+    # OutputManager handles list of Pydantic models automatically for both JSON and Table
+    print_output(actions, title="Available Actions")
+
+@app.command(name="list")
+def list_providers(
+    json: AgentOutput = False,
+    force: bool = typer.Option(False, "--force", "-f", help="Force refresh of agent state")
+):
+    """List available agent providers and their status."""
+    # Reuse status logic
+    status(json=json, force=force)
 
 @app.command()
 def status(
-    json: bool = typer.Option(False, "--json", help="Output in JSON format"),
+    json: AgentOutput = False,
     force: bool = typer.Option(False, "--force", "-f", help="Force refresh of agent state")
 ):
     """View status of Agent Providers."""
     state_manager = AgentStateManager()
     state = state_manager.get_or_refresh(force=force)
     
-    if json:
-        import json as j
+    if OutputManager.is_agent_mode():
         # Convert datetime to ISO string for JSON serialization
         data = state.dict()
         data["last_checked"] = data["last_checked"].isoformat()
-        print(j.dumps(data, indent=2))
+        OutputManager.print(data)
     else:
         # Standard output using existing print_output or custom formatting
         from monoco.core.output import Table
+        from rich import print as rprint
+        
         table = Table(title=f"Agent Status (Last Checked: {state.last_checked.strftime('%Y-%m-%d %H:%M:%S')})")
         table.add_column("Provider")
         table.add_column("Available")
@@ -147,7 +205,7 @@ def status(
                 p_state.path or "-",
                 p_state.error or "-"
             )
-        print_output(table)
+        rprint(table)
 
 @app.command()
 def doctor(
@@ -158,3 +216,22 @@ def doctor(
     """
     from monoco.features.agent.doctor import doctor as doc_impl
     doc_impl(force)
+
+@app.command()
+def init(
+    force: bool = typer.Option(False, "--force", "-f", help="Force overwrite existing resources")
+):
+    """
+    Initialize Agent Resources (prompts) in the current project.
+    """
+    settings = get_config()
+    root = Path(settings.paths.root)
+    
+    from monoco.features.agent.core import init_agent_resources
+    # TODO: Pass force arg when supported by core
+    init_agent_resources(root)
+    
+    if OutputManager.is_agent_mode():
+        OutputManager.print({"status": "initialized"})
+    else:
+        print(f"Agent resources initialized in {root}")

monoco/features/agent/core.py

@@ -0,0 +1,48 @@
+import shutil
+import os
+from pathlib import Path
+from typing import List
+try:
+    from importlib.resources import files
+except ImportError:
+    # Fallback for python < 3.9
+    from importlib_resources import files
+
+def init_agent_resources(project_root: Path):
+    """
+    Initialize Agent resources (prompts) in the project workspace.
+    """
+    actions_dir = project_root / ".monoco" / "actions"
+    actions_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Determine language from config, default to 'en'
+    # We need to load config to know the language. 
+    # But this function might be called before full config load?
+    # Helper to peek at config or default to 'en'
+    from monoco.core.config import get_config
+    try:
+        settings = get_config(str(project_root), require_project=False) # Best effort
+        lang = settings.core.language or "en"
+    except Exception:
+        lang = "en"
+
+    # Define source path relative to this module
+    try:
+        current_dir = Path(__file__).parent
+        
+        # Try specific language, fallback to 'en'
+        source_dir = current_dir / "resources" / lang
+        if not source_dir.exists():
+             source_dir = current_dir / "resources" / "en"
+        
+        if source_dir.exists():
+            for item in source_dir.glob("*.prompty"):
+                target = actions_dir / item.name
+                # Copy if not exists, or overwrite? 
+                # Ideally init should be safe to run multiple times (idempotent)
+                # But user might have customized them.
+                if not target.exists():
+                     shutil.copy2(item, target)
+    except Exception as e:
+        # Fallback or Log?
+        pass