monoco-toolkit 0.3.2__py3-none-any.whl → 0.3.5__py3-none-any.whl

{monoco_toolkit-0.3.2.dist-info → monoco_toolkit-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monoco-toolkit
-Version: 0.3.2
+Version: 0.3.5
 Summary: Agent Native Toolkit for Monoco - Task Management & Kanban for AI Agents
 Project-URL: Homepage, https://monoco.io
 Project-URL: Repository, https://github.com/IndenScale/Monoco
@@ -40,45 +40,37 @@ Description-Content-Type: text/markdown
 
 > **The Operating System for Agentic Engineering.**
 >
-> Ground your AI Agents into deterministic workflows. Turn vague "chats" into structured, validatable, and shippable engineering units.
+> Stop chatting. Start building.
+> Monoco grounds your AI Agents into deterministic, validatable, and shippable engineering workflows.
 
 ---
 
-## ⚡️ Why Monoco?
+## ⚡️ The Gap: "Chat" is not Engineering.
 
-In the era of LLMs, the bottleneck isn't **intelligence**—it's **control**.
+Generating code is easy. **Engineering**—managing dependencies, maintaining state, validation, and version control—is hard.
 
-Generating code is easy. Managing the lifecycle of thousands of agent-generated tasks, validating their outputs, and maintaining a coherent project state is hard. **Monoco** is the missing control plane that bridges the gap between raw AI velocity and strict engineering rigor.
+Most Agent workflows today are fragile "chats". Monoco turns them into **Software Engineering Processes**. It acts as the "BizOps" layer for your Agents, ensuring that every line of code generated is tracked, reviewed, and aligned with the project roadmap.
 
-Monoco handles the **"BizOps Logic"** of your development process, allowing you to orchestrate human and AI labor within a unified, version-controlled environment.
+## 🌟 Core Philosophy
 
-## 🌟 Core Features
+### 1. Co-pilot by Design
 
-### 1. Issue as Code (IaaC)
+**Just-enough Automation.**
+Monoco abstracts away the tedious details (Git ops, state tracking) while keeping you securely in the driver's seat. Agents can suggest and build, but **you** always have the final say on what gets merged.
 
-Treat your project management like your code.
+### 2. Battle-Tested Best Practices
 
-- **Markdown Native**: All tasks (Epics, Features, Chores) are stored as structured Markdown files in your repository.
-- **Git Backed**: Version control your roadmap. Review changes to requirements via Pull Requests.
-- **Universal Context**: Provides a standardized, hallucination-free state representation for AI Agents.
+**Senior Engineer Intuition.**
+Monoco enforces **Issue Driven Development (IDD)** and standard **Git Workflows**. We bake the rigorous habits of effective software teams into the Agent's core loop, ensuring every line of code is traceable and reviewed.
 
-### 2. The Agent Cockpit (VS Code Extension)
+### 3. Radical Transparency (Dogfooding)
 
-Stop context switching. Manage your entire agentic workflow directly inside your editor.
-
-- **Native Kanban Board**: Visualize and drag-and-drop tasks without leaving VS Code.
-- **Hierarchical Tree View**: Drill down from high-level Epics to atomic Implementation Tasks.
-- **Agent Integration**: Bind specific Agent Providers (Gemini, Claude, etc.) to specific tasks.
-
-### 3. Traceable Execution
-
-- **Deterministic State Machine**: Every task follows a strict lifecycle (Proposed -> Approved -> Doing -> Review -> Done).
-- **Audit Trails**: Agents log their actions and decisions directly into the task file.
-- **Sanity Checks**: Built-in linters ensure your task definitions are complete and valid before execution.
+**Process as Product.**
+Monoco is built by Monoco. We believe in open-sourcing not just the code, but the engineering process itself. Every design decision, interaction log, and failure is public—providing a live blueprint for Agentic Engineering.
 
 ## 🚀 Quick Start
 
-### Installation
+### 1. Installation
 
 Monoco is available as a Python CLI tool.
 
@@ -86,33 +78,32 @@ Monoco is available as a Python CLI tool.
 pip install monoco-toolkit
 ```
 
-### Initialization
+### 2. Workspace Initialization
 
-Turn any directory into a Monoco workspace.
+Turn any directory into a Monoco Workspace. This creates the `.monoco` config and the `Issues/` directory.
 
 ```bash
 monoco init
 ```
 
-### Workflow
-
-1.  **Plan**: Create a new feature request.
-    ```bash
-    monoco issue create feature -t "Implement Dark Mode"
-    ```
-2.  **Start**: Create a feature branch automatically.
-    ```bash
-    monoco issue start FEAT-001 --branch
-    ```
-3.  **Code & Sync**: Track modified files automatically.
-    ```bash
-    monoco issue sync-files
-    ```
-4.  **Visualize**: Open the board in VS Code or via CLI.
-    ```bash
-    # Starts the local server
-    monoco serve
-    ```
+### 3. Agent Synchronization
+
+**Crucial Step**: This injects the "Monoco System Neural Network" (System Prompts & Skills) into your agent configuration files (e.g., `GEMINI.md`, `CLAUDE.md`).
+
+```bash
+monoco sync
+```
+
+### 4. The Engineering Loop (Agent-First)
+
+In Monoco, you don't need to memorize CLI commands. **The Agent is your DevOps Engineer.**
+
+1.  **Chat**: Tell your Agent in the chatbox (e.g., _"Implement Dark Mode"_).
+2.  **Plan**: The Agent investigates and proposes an **Issue Ticket** for your review.
+3.  **Build**: Once approved, the Agent creates a branch, writes code, and submits changes.
+4.  **Ship**: You accept the results. The Agent handles the merge and closure.
+
+---
 
 ## 📦 Extension for VS Code
 

{monoco_toolkit-0.3.2.dist-info → monoco_toolkit-0.3.5.dist-info}/RECORD

@@ -1,29 +1,24 @@
-monoco/main.py,sha256=_ZhokFhmYF1NNHubuVr9gZ_HLg6AaZPWMppnUESbpwA,5346
+monoco/main.py,sha256=MscjwDCOT2DfZKpZMEZEn-M1INmqu4-4R200GEiBwrc,5562
 monoco/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/cli/project.py,sha256=FqLaDD3hiWxa0_TKzxEF7PYH9RPsvmLyjO3NYVckgGs,2737
 monoco/cli/workspace.py,sha256=1TVVS835XyirLDvBGQXSblIaYVhe2Pk9EpORDvcktyk,1538
 monoco/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monoco/core/config.py,sha256=DsxkUaHbKK17JuMzcYLVBWnLhhs78HC_gday2fyx6sw,12250
+monoco/core/config.py,sha256=M9F5De2FUgaIxFwqZBoJUXsMsph31rNh-4U-k_9rUHA,13543
 monoco/core/execution.py,sha256=7522s7uVWiNdMKtWlIb8JHzbAcJgLVuxUFp_6VmhWNQ,1801
 monoco/core/feature.py,sha256=bcK0C1CaQgNLcdMF0RuniaaQRCYSA-0JdOpQz9W_1xM,1968
 monoco/core/git.py,sha256=d3A8L30nlEj0F1pwSHk_cOoRYi1dMCiZc7KD70ViMyw,8335
 monoco/core/hooks.py,sha256=QY4c74LIYDtcjtWYax1PrK5CtVNKYTfVVVBOj-SCulo,1826
 monoco/core/injection.py,sha256=zs9RpXaBfwP-fbwOU_X2nm-AH94tQN9tVWXNtV4tCYM,6887
-monoco/core/integrations.py,sha256=GOWwDceEuhU6Q1nX8vvyGQ7s_kzuW0lKK23nEFkzCT0,7912
+monoco/core/integrations.py,sha256=ifSz7I87DXHF-eHLyXRN3pY1-Kh8IjvMyIrG9iogGpw,7744
 monoco/core/lsp.py,sha256=GOrHzubkMWS3iBpP4H2fTFW-0JXa6D2YlU0ZEhp5zmY,2018
 monoco/core/output.py,sha256=ZlUydZ65FIP5a32_eESIIvMrhcSwghIqZ3N23OSx6Ss,3878
 monoco/core/registry.py,sha256=1m9wvkcqWqrTcARt-jUGHH1BEYMvp0NJGRkq-uduJeg,1167
 monoco/core/setup.py,sha256=YUIhzqZwjEeH7zGZm9SPA-OhgTISJtA6ByNFCGBznUU,11487
 monoco/core/skills.py,sha256=KeVN09KIcRiksjJ91AggJbN_EvjRQfMGqd_hUQfUjes,16168
 monoco/core/state.py,sha256=dfoTH1Sj_TSjtTEXuv4w0ZOp_Fd30XNymVSZo30Xshg,1820
-monoco/core/sync.py,sha256=DJXnWM_LxN36VniTUS5axFiAhVXYHbxLbI1uaUvV1JU,8750
+monoco/core/sync.py,sha256=1p37pTfGBanogzcLhdTfMTxDqq79B5iiwiPS4fiuQaA,8378
 monoco/core/telemetry.py,sha256=GQDbtgrZwAL1ZpjgbJZuawbTyH6J0NjMXMi4ogq-Ang,2915
 monoco/core/workspace.py,sha256=H_PHD5A0HZFq841u1JtLoFjkXdQg9D6x6I7QcFtJge4,3000
-monoco/core/agent/__init__.py,sha256=iU3wac9iYecA1M2jaYnnPjU9wANdAS7B-jRAuT5gCo4,38
-monoco/core/agent/action.py,sha256=qkQGJERhL4N5MSuwDivn8NAw4sMhEa346huGtqNyFTM,5295
-monoco/core/agent/adapters.py,sha256=q6obVcXve46mVNBaSCBRFRYs8gImv6Y2gAJVv173Z6w,4376
-monoco/core/agent/protocol.py,sha256=eB0OiMjDQu1DOoeVqb_PpHsMyPy2LdNenNyt4vJ9qbQ,798
-monoco/core/agent/state.py,sha256=Z8qqY7loms5nt3524_TrEMmlpnurxf0aHfiCT1FgvDI,3385
 monoco/core/resources/en/AGENTS.md,sha256=vf9z43UU-LPwYKPWCrtw8TpWrmkeZ6zfMyHP4Q9JqdQ,1178
 monoco/core/resources/en/SKILL.md,sha256=wBXNpPqATOxO8TGiOM8S091gMNZ8du_WhQubO6TfNyg,3504
 monoco/core/resources/zh/AGENTS.md,sha256=KBNZSCPBIals6jDdvG5wJgjZuswi_1nKljggJSMtfy8,1156
@@ -46,16 +41,21 @@ monoco/features/i18n/resources/en/SKILL.md,sha256=Z8fAAqeMvpLDw1D_9AzZIykS5-HLVM
 monoco/features/i18n/resources/zh/AGENTS.md,sha256=lKkwLLCADRH7UDq9no4eQY2sRfJrb64JoZ_HNved8vA,175
 monoco/features/i18n/resources/zh/SKILL.md,sha256=Wynk7zVBW7CO0_6AEQNUvlD_3eMW_7EPnzEn9QUaiDs,1884
 monoco/features/issue/adapter.py,sha256=4dzKg4-0XH63uORoh8qcolvKxJR6McBDIYxYEcZJJkA,1204
-monoco/features/issue/commands.py,sha256=ndBE_3tP4CZK45lqAbsGpeopzvebMZKeIezZchTGIsc,37353
-monoco/features/issue/core.py,sha256=WoWZRpw7o9f6ERqqIgD35c-SYD7Jv1aTsJVj6ljPz9E,50369
-monoco/features/issue/linter.py,sha256=DQ3UruGUUMZu63EFn71eczoFDoqj31JxHHaRR3Ej6O8,21067
+monoco/features/issue/commands.py,sha256=vaScb2J4qjUvO8DSlKhTrGDSfIyJ4zIUr14jhBlG6tE,37581
+monoco/features/issue/core.py,sha256=kRyUbYqEBno0Zoogq7dMIcQv5M0QIRSlptvzp0pfImE,51302
+monoco/features/issue/domain_commands.py,sha256=eatSF_uZp4nGpVr2PIgb00MWfEBm0OnyAd4JvUJEAAA,1535
+monoco/features/issue/domain_service.py,sha256=bEs_WXOWmotgIR-lGwyWekF4nonvjsgrK1YG3pyVfwk,2564
+monoco/features/issue/linter.py,sha256=LLtJEVIzoGTNm1liZARJHM3-V-EODkGRuw3ExCZtEjY,26115
 monoco/features/issue/migration.py,sha256=i0xlxZjrpmuHGHOAIN4iu31EwwVIvZn7yjveS-kU22c,4896
 monoco/features/issue/models.py,sha256=7oIMxvUEfe00n7wni9bZgKU2e9404flvArixbLQ95Dg,5902
 monoco/features/issue/monitor.py,sha256=vZN0TbR3V5fHKHRGkIhimO6UwWcwYjDHQs2qzjEG174,3549
-monoco/features/issue/validator.py,sha256=Rbn5M_RLEHVPi5n0Y19-VCWZvVlRWcCRFYRbsw-Oc-I,24732
+monoco/features/issue/resolver.py,sha256=mAU9s7TNNHY9A2278JTwJvxU-jalGKTDJfJdjONev3E,5655
+monoco/features/issue/test_priority_integration.py,sha256=Kq3XMQYkQK62R-a_lmAeEpGlZr4nRBbG6WAyW430el8,2763
+monoco/features/issue/test_resolver.py,sha256=luFhK37DUvh4a3TTcFYVO-oOIJljQVCSYicwSWyDleQ,2530
+monoco/features/issue/validator.py,sha256=GYqbx2-ZxXfk1HicgBXkpL__v83KK-jcOyo7eW-VRUs,27793
 monoco/features/issue/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/features/issue/domain/lifecycle.py,sha256=oIuLYTVy1RRHGngAzbNU4kTWOHMBhjuw_TuYCwNqMJw,4991
-monoco/features/issue/domain/models.py,sha256=eo5Ks7VzWDQsqzuu9gcBuxIafvfqnzUDNDG9wbaghsc,5797
+monoco/features/issue/domain/models.py,sha256=2vuSAGaFrbAEkQapwkGG_T8cHlsmARN71fTA44PIVSM,5850
 monoco/features/issue/domain/parser.py,sha256=axfB9BjY-m4DQqYwTQBm_38plOidZaDqFtsIejW_kYI,9095
 monoco/features/issue/domain/workspace.py,sha256=nyTEFNmpLPuX7nssMCBiFI1XBhY9zbqG877Ppp_s0Fg,3658
 monoco/features/issue/engine/__init__.py,sha256=-SBvzjlZJz0O-IB1c95d9pbhr3lydJNLq2vhnfkZ8PQ,747
@@ -64,10 +64,20 @@ monoco/features/issue/engine/machine.py,sha256=Bun_5jHlFRA7Duy7zG8f1GZIbZlPKt6C7
 monoco/features/issue/engine/models.py,sha256=595Sx3ncrpg_PhnbBLthohAvuhnjA-_9oXcrsT6Lv0k,574
 monoco/features/issue/lsp/__init__.py,sha256=8bl8-WzSj3C4SkPKgVGnCeyemmvHVWBsuMZsJuJggG8,77
 monoco/features/issue/lsp/definition.py,sha256=cF6Quw1OztuKMJ1zLvgA_ek7lTAdzHF0m4LVznpbAPw,3203
-monoco/features/issue/resources/en/AGENTS.md,sha256=7lMJdLhokispHVTrViIyMaz5TOJ88GkPKfWZp4FlgRQ,1015
+monoco/features/issue/resources/en/AGENTS.md,sha256=eHHXjLRDAV7IKrYPQSilxu0X5D0SBCAFBXmlSoc9r48,1278
 monoco/features/issue/resources/en/SKILL.md,sha256=M5khTJdraQenX0tf7RHOVcqyKHC285qwDzWdsCJ7XPI,4032
-monoco/features/issue/resources/zh/AGENTS.md,sha256=veb22lU0qindYcsNsuGLqzpBEjExCPDOkX5Q39OjZz0,1113
+monoco/features/issue/resources/zh/AGENTS.md,sha256=oRHHqeDYx6aEc5FfdL7a-zqT7uh4SYIYt8QBRKEKrYM,1351
 monoco/features/issue/resources/zh/SKILL.md,sha256=XFE33cCCos0U1IVNkMhU7fGuqVqfxo_FNKdp1aScaoM,5055
+monoco/features/scheduler/__init__.py,sha256=hvE9A14qFTeTYbWlK9iMRdXIFLMBuG8724GEZzFTHB8,483
+monoco/features/scheduler/cli.py,sha256=NgsGwCf615YA4VGd-mqMpGp5VCjdMUqoZqiHZFnDdLU,8325
+monoco/features/scheduler/config.py,sha256=69PTvKGHJ33fA2yhFJAq0WVq70Zbmdd5X8Wl0vIYAak,2336
+monoco/features/scheduler/defaults.py,sha256=4Ne3RpF7gZ46BmHtF0hC8wYkuCIkDSuKB7hGnHhGXms,2208
+monoco/features/scheduler/engines.py,sha256=ICKw4Kfme6UNl_JLJvT7hADKHo76Yr8wpFFEvtEV6z4,3799
+monoco/features/scheduler/manager.py,sha256=PmNKqfktgrdpUwE-jPE_WX3IvzZat0JKdEcmzse08-0,1680
+monoco/features/scheduler/models.py,sha256=rb8rx8t_TD5ilUC6xU3jvK0sud7YUZE_iEdes9Np8R0,877
+monoco/features/scheduler/reliability.py,sha256=zVwtnksug5wr0_tigC2Qjl_C8VNyrheN_34ItUceGoo,3846
+monoco/features/scheduler/session.py,sha256=V1xFXA65BaERhBwRYIecaye2TjDtFvAzuIy2gZ68ag8,2954
+monoco/features/scheduler/worker.py,sha256=4OU2Y7nG5EKadNIKDF5GWl5V7vgVl3OPlYHShfiEeBI,4538
 monoco/features/skills/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/features/skills/core.py,sha256=BXVvMot8E457-pj9U19lPHypBVhdLQRsx0zEAXJxpGY,3436
 monoco/features/spike/adapter.py,sha256=ZIpw-xNVoA2IIP18dbR-dmQGbQmK5ua_P-uGXuDjCeI,1021
@@ -77,8 +87,8 @@ monoco/features/spike/resources/en/AGENTS.md,sha256=NG3CMnlDk_0J8hnRUcueAM9lgIQr
 monoco/features/spike/resources/en/SKILL.md,sha256=qKDcVh0D3pDRvfNLh1Bzo4oQU3obpl4tqdlzxeiWYMk,1911
 monoco/features/spike/resources/zh/AGENTS.md,sha256=5RHNl7fc3RdYYTFH483ojJl_arGPKkyYziOuGgFbqqg,290
 monoco/features/spike/resources/zh/SKILL.md,sha256=Q82e9lCQOAYIwBs5rGnvlVUDq7bp0pz8yvO10KTWFYQ,1710
-monoco_toolkit-0.3.2.dist-info/METADATA,sha256=9Xyk-ImLkR4WvBAz6eQb8_N-QZiJ7TPu27P3u48Y35c,4866
-monoco_toolkit-0.3.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-monoco_toolkit-0.3.2.dist-info/entry_points.txt,sha256=iYj7FWYBdtClU15-Du1skqD0s6SFSIhJvxJ29VWp8ng,43
-monoco_toolkit-0.3.2.dist-info/licenses/LICENSE,sha256=ACAGGjV6aod4eIlVUTx1q9PZbnZGN5bBwkSs9RHj83s,1071
-monoco_toolkit-0.3.2.dist-info/RECORD,,
+monoco_toolkit-0.3.5.dist-info/METADATA,sha256=UD0y77LYaDLy3ZoMUphV87XScSEg8G3kGxld1DhD8Wk,4732
+monoco_toolkit-0.3.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+monoco_toolkit-0.3.5.dist-info/entry_points.txt,sha256=iYj7FWYBdtClU15-Du1skqD0s6SFSIhJvxJ29VWp8ng,43
+monoco_toolkit-0.3.5.dist-info/licenses/LICENSE,sha256=ACAGGjV6aod4eIlVUTx1q9PZbnZGN5bBwkSs9RHj83s,1071
+monoco_toolkit-0.3.5.dist-info/RECORD,,

monoco/core/agent/__init__.py

@@ -1,3 +0,0 @@
-"""
-Monoco Agent Execution Layer.
-"""

monoco/core/agent/action.py

@@ -1,168 +0,0 @@
-import re
-import yaml
-from pathlib import Path
-from typing import Dict, List, Optional, Any
-from pydantic import BaseModel
-
-
-class ActionContext(BaseModel):
-    """Context information for matching actions."""
-
-    id: Optional[str] = None
-    type: Optional[str] = None
-    stage: Optional[str] = None
-    status: Optional[str] = None
-    file_path: Optional[str] = None
-    project_id: Optional[str] = None
-
-
-class ActionWhen(BaseModel):
-    """Conditions under which an action should be displayed/active."""
-
-    idMatch: Optional[str] = None
-    typeMatch: Optional[str] = None
-    stageMatch: Optional[str] = None
-    statusMatch: Optional[str] = None
-    fileMatch: Optional[str] = None
-
-    def matches(self, context: ActionContext) -> bool:
-        """Evaluate if the context matches these criteria."""
-        if self.idMatch and context.id and not re.match(self.idMatch, context.id):
-            return False
-        if (
-            self.typeMatch
-            and context.type
-            and not re.match(self.typeMatch, context.type)
-        ):
-            return False
-        if (
-            self.stageMatch
-            and context.stage
-            and not re.match(self.stageMatch, context.stage)
-        ):
-            return False
-        if (
-            self.statusMatch
-            and context.status
-            and not re.match(self.statusMatch, context.status)
-        ):
-            return False
-        if (
-            self.fileMatch
-            and context.file_path
-            and not re.match(self.fileMatch, context.file_path)
-        ):
-            return False
-        return True
-
-
-class PromptyAction(BaseModel):
-    name: str
-    description: str
-    version: Optional[str] = "1.0.0"
-    authors: List[str] = []
-    model: Dict[str, Any] = {}
-    inputs: Dict[str, Any] = {}
-    outputs: Dict[str, Any] = {}
-    template: str
-    when: Optional[ActionWhen] = None
-
-    # Monoco specific metadata
-    path: Optional[str] = None
-    provider: Optional[str] = None  # Derived from model.api or explicitly set
-
-
-class ActionRegistry:
-    def __init__(self, project_root: Optional[Path] = None):
-        self.project_root = project_root
-        self._actions: List[PromptyAction] = []
-
-    def scan(self) -> List[PromptyAction]:
-        """Scan user global and project local directories for .prompty files."""
-        self._actions = []
-
-        # 1. User Global: ~/.monoco/actions/
-        user_dir = Path.home() / ".monoco" / "actions"
-        self._scan_dir(user_dir)
-
-        # 2. Project Local: {project_root}/.monoco/actions/
-        if self.project_root:
-            project_dir = self.project_root / ".monoco" / "actions"
-            self._scan_dir(project_dir)
-
-        return self._actions
-
-    def _scan_dir(self, directory: Path):
-        if not directory.exists():
-            return
-
-        for prompty_file in directory.glob("*.prompty"):
-            try:
-                action = self._load_action(prompty_file)
-                if action:
-                    self._actions.append(action)
-            except Exception as e:
-                print(f"Failed to load action {prompty_file}: {e}")
-
-    def _load_action(self, file_path: Path) -> Optional[PromptyAction]:
-        content = file_path.read_text(encoding="utf-8")
-
-        # Prompty Parser (Standard YAML Frontmatter + Body)
-        # We look for the first --- and the second ---
-        parts = re.split(r"^---\s*$", content, maxsplit=2, flags=re.MULTILINE)
-
-        if len(parts) < 3:
-            return None
-
-        frontmatter_raw = parts[1]
-        body = parts[2].strip()
-
-        try:
-            meta = yaml.safe_load(frontmatter_raw)
-            if not meta or "name" not in meta:
-                # Use filename as fallback name if missing? Prompty usually requires name.
-                if not meta:
-                    meta = {}
-                meta["name"] = meta.get("name", file_path.stem)
-
-            # Map Prompty 'when' if present
-            when_data = meta.get("when")
-            when = ActionWhen(**when_data) if when_data else None
-
-            action = PromptyAction(
-                name=meta["name"],
-                description=meta.get("description", ""),
-                version=meta.get("version"),
-                authors=meta.get("authors", []),
-                model=meta.get("model", {}),
-                inputs=meta.get("inputs", {}),
-                outputs=meta.get("outputs", {}),
-                template=body,
-                when=when,
-                path=str(file_path.absolute()),
-                provider=meta.get("provider") or meta.get("model", {}).get("api"),
-            )
-            return action
-
-        except Exception as e:
-            print(f"Invalid Prompty in {file_path}: {e}")
-            return None
-
-    def list_available(
-        self, context: Optional[ActionContext] = None
-    ) -> List[PromptyAction]:
-        if not self._actions:
-            self.scan()
-
-        if not context:
-            return self._actions
-
-        return [a for a in self._actions if not a.when or a.when.matches(context)]
-
-    def get(self, name: str) -> Optional[PromptyAction]:
-        if not self._actions:
-            self.scan()
-        for a in self._actions:
-            if a.name == name:
-                return a
-        return None

monoco/core/agent/adapters.py

@@ -1,133 +0,0 @@
-"""
-CLI Adapters for Agent Frameworks.
-"""
-
-import shutil
-from typing import List
-from pathlib import Path
-from .protocol import AgentClient
-
-
-class BaseCLIClient:
-    def __init__(self, executable: str):
-        self._executable = executable
-
-    @property
-    def name(self) -> str:
-        return self._executable
-
-    async def available(self) -> bool:
-        return shutil.which(self._executable) is not None
-
-    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 ---")
-            for file_path in context_files:
-                try:
-                    full_prompt.append(f"\nFile: {file_path}")
-                    full_prompt.append("```")
-                    # Read file content safely
-                    full_prompt.append(
-                        file_path.read_text(encoding="utf-8", errors="replace")
-                    )
-                    full_prompt.append("```")
-                except Exception as e:
-                    full_prompt.append(f"Error reading {file_path}: {e}")
-            full_prompt.append("--- END CONTEXT ---\n")
-        return "\n".join(full_prompt)
-
-    async def _run_command(self, args: List[str]) -> str:
-        """Run the CLI command and return stdout."""
-        # Using synchronous subprocess in async function for now
-        # Ideally this should use asyncio.create_subprocess_exec
-        import asyncio
-
-        proc = await asyncio.create_subprocess_exec(
-            *args, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
-        )
-
-        stdout, stderr = await proc.communicate()
-
-        if proc.returncode != 0:
-            error_msg = stderr.decode().strip()
-            raise RuntimeError(
-                f"Agent CLI failed (code {proc.returncode}): {error_msg}"
-            )
-
-        return stdout.decode().strip()
-
-
-class GeminiClient(BaseCLIClient, AgentClient):
-    """Adapter for Google Gemini CLI."""
-
-    def __init__(self):
-        super().__init__("gemini")
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        full_prompt = self._build_prompt(prompt, context_files)
-        # Usage: gemini "prompt"
-        return await self._run_command([self._executable, full_prompt])
-
-
-class ClaudeClient(BaseCLIClient, AgentClient):
-    """Adapter for Anthropic Claude CLI."""
-
-    def __init__(self):
-        super().__init__("claude")
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        full_prompt = self._build_prompt(prompt, context_files)
-        # Usage: claude -p "prompt"
-        return await self._run_command([self._executable, "-p", full_prompt])
-
-
-class QwenClient(BaseCLIClient, AgentClient):
-    """Adapter for Alibaba Qwen CLI."""
-
-    def __init__(self):
-        super().__init__("qwen")
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        full_prompt = self._build_prompt(prompt, context_files)
-        # Usage: qwen "prompt"
-        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,
-    "kimi": KimiClient,
-}
-
-
-def get_agent_client(name: str) -> AgentClient:
-    """Factory to get agent client by name."""
-    if name not in _ADAPTERS:
-        raise ValueError(f"Unknown agent provider: {name}")
-    return _ADAPTERS[name]()

monoco/core/agent/protocol.py

@@ -1,32 +0,0 @@
-"""
-Protocol definition for Agent Clients.
-"""
-
-from typing import Protocol, List
-from pathlib import Path
-
-
-class AgentClient(Protocol):
-    """Protocol for interacting with CLI-based agents."""
-
-    @property
-    def name(self) -> str:
-        """Name of the agent provider (e.g. 'gemini', 'claude')."""
-        ...
-
-    async def available(self) -> bool:
-        """Check if the agent is available in the current environment."""
-        ...
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        """
-        Execute a prompt against the agent.
-
-        Args:
-            prompt: The main instructions.
-            context_files: List of files to provide as context.
-
-        Returns:
-            The raw string response from the agent.
-        """
-        ...

monoco/core/agent/state.py

@@ -1,106 +0,0 @@
-"""
-Agent State Management.
-
-Handles persistence and retrieval of agent availability state.
-"""
-
-import yaml
-import logging
-from pathlib import Path
-from datetime import datetime, timezone
-from typing import Dict, Optional
-from pydantic import BaseModel
-
-logger = logging.getLogger("monoco.core.agent.state")
-
-
-class AgentProviderState(BaseModel):
-    available: bool
-    path: Optional[str] = None
-    error: Optional[str] = None
-    latency_ms: Optional[int] = None
-
-
-class AgentState(BaseModel):
-    last_checked: datetime
-    providers: Dict[str, AgentProviderState]
-
-    @property
-    def is_stale(self) -> bool:
-        """Check if the state is older than 7 days."""
-        delta = datetime.now(timezone.utc) - self.last_checked
-        return delta.days > 7
-
-
-class AgentStateManager:
-    def __init__(self, state_path: Path = Path.home() / ".monoco" / "agent_state.yaml"):
-        self.state_path = state_path
-        self._state: Optional[AgentState] = None
-
-    def load(self) -> Optional[AgentState]:
-        """Load state from file, returning None if missing or invalid."""
-        if not self.state_path.exists():
-            return None
-
-        try:
-            with open(self.state_path, "r") as f:
-                data = yaml.safe_load(f)
-                if not data:
-                    return None
-                # Handle ISO string to datetime conversion if needed provided by Pydantic mostly
-                return AgentState(**data)
-        except Exception as e:
-            logger.warning(f"Failed to load agent state: {e}")
-            return None
-
-    def get_or_refresh(self, force: bool = False) -> AgentState:
-        """Get current state, refreshing if missing, stale, or forced."""
-        if not force:
-            self._state = self.load()
-            if self._state and not self._state.is_stale:
-                return self._state
-
-        return self.refresh()
-
-    def refresh(self) -> AgentState:
-        """Run diagnostics on all integrations and update state."""
-        logger.info("Refreshing agent state...")
-
-        from monoco.core.integrations import get_all_integrations
-        from monoco.core.config import get_config
-
-        # 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
-
-            health = integration.check_health()
-            providers[key] = AgentProviderState(
-                available=health.available,
-                path=health.path,
-                error=health.error,
-                latency_ms=health.latency_ms,
-            )
-
-        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)
-
-        self._state = state
-        return state
-
-    def _find_script(self) -> Optional[Path]:
-        """[Deprecated] No longer used."""
-        return None