monoco-toolkit 0.3.9__py3-none-any.whl → 0.3.10__py3-none-any.whl

monoco/features/issue/resources/zh/skills/issue_refine_workflow/SKILL.md

@@ -0,0 +1,203 @@
+---
+name: issue-refine-workflow
+description: 调查并细化 Issue，补充技术细节和实现方案 (Copilot 模式)
+type: flow
+domain: issue
+version: 1.0.0
+---
+
+# Issue Refine Workflow
+
+对新创建或待细化的 Issue 进行技术调查、架构分析和方案设计的标准化工作流。
+
+**适用场景**: Copilot 模式（人类主导，AI 辅助）
+**目标用户**: 需要深入理解问题并制定实现方案的开发者
+
+## 工作流状态机
+
+```mermaid
+stateDiagram-v2
+    [*] --> Investigate: 开始细化
+    
+    Investigate --> Analyze: 收集信息
+    Investigate --> Investigate: 信息不足<br/>(继续调查)
+    
+    Analyze --> Architect: 需要架构设计
+    Analyze --> Document: 直接文档化
+    
+    Architect --> Document: 设计完成
+    
+    Document --> [*]: Issue 细化完成
+```
+
+## 执行步骤
+
+### 1. Investigate (调查)
+
+- **目标**: 全面收集与 Issue 相关的信息
+- **输入**: Issue Ticket、相关代码、文档
+- **输出**: 信息收集报告
+- **检查点**:
+  - [ ] 阅读 Issue 描述，理解核心问题
+  - [ ] 识别相关代码模块和文件
+  - [ ] 查看相关 Issue/PR 历史
+  - [ ] 检查外部依赖和约束条件
+  - [ ] 收集类似实现参考（Spike）
+
+**调查维度**:
+| 维度 | 调查内容 |
+|------|----------|
+| 代码 | 相关模块的当前实现 |
+| 历史 | 相关 Issue、PR、设计文档 |
+| 依赖 | 外部库、API、服务依赖 |
+| 约束 | 性能要求、安全要求、兼容性 |
+| 参考 | 类似功能的最佳实践 |
+
+### 2. Analyze (分析)
+
+- **目标**: 分析收集的信息，识别关键问题和方案选项
+- **检查点**:
+  - [ ] 分析架构继承性（如何融入现有架构）
+  - [ ] 评估安全性影响
+  - [ ] 评估性能影响
+  - [ ] 评估可维护性
+  - [ ] 识别潜在风险和缓解措施
+
+**分析框架**:
+
+#### 架构继承性
+- 现有架构模式是否适用？
+- 是否需要引入新的抽象层？
+- 对现有模块的耦合影响？
+
+#### 安全性评估
+- 输入验证需求
+- 权限控制需求
+- 数据保护需求
+- 潜在攻击面分析
+
+#### 性能评估
+- 时间复杂度影响
+- 空间复杂度影响
+- 并发/并行需求
+- 资源使用预估
+
+#### 可维护性评估
+- 代码复杂度变化
+- 测试覆盖需求
+- 文档更新需求
+- 后续扩展性
+
+### 3. Architect (架构) - 可选
+
+- **目标**: 对复杂 Issue 进行架构设计
+- **适用**: 涉及架构变更或大型功能
+- **检查点**:
+  - [ ] 确定技术方案选型
+  - [ ] 设计接口和交互协议
+  - [ ] 规划数据模型变更
+  - [ ] 制定实现里程碑
+
+**输出物**:
+- 架构决策记录 (ADR)
+- 接口设计文档
+- 数据模型变更
+- 里程碑计划
+
+### 4. Document (文档)
+
+- **目标**: 将分析结果更新到 Issue
+- **检查点**:
+  - [ ] 更新技术任务清单
+  - [ ] 添加架构决策说明
+  - [ ] 补充风险和缓解措施
+  - [ ] 更新验收标准（如需要）
+  - [ ] 添加参考链接和依赖说明
+  - [ ] 运行 `monoco issue lint` 验证合规性
+
+**细化后 Issue 结构**:
+
+```markdown
+## Objective
+[原有内容]
+
+## Acceptance Criteria
+- [ ] 验收标准 1
+- [ ] 验收标准 2
+
+## Technical Analysis
+
+### 现状分析
+描述当前代码状态和相关实现。
+
+### 方案选型
+| 方案 | 优点 | 缺点 | 决策 |
+|------|------|------|------|
+| A | ... | ... | 采纳/备选 |
+| B | ... | ... | 备选/放弃 |
+
+### 风险评估
+| 风险 | 影响 | 缓解措施 |
+|------|------|----------|
+| 风险1 | 高/中/低 | 措施... |
+
+## Technical Tasks
+- [ ] 任务 1
+- [ ] 任务 2
+
+## References
+- 相关 Issue: #XXX
+- 参考实现: [链接]
+- ADR: [链接]
+```
+
+## 决策分支
+
+| 条件 | 动作 |
+|------|------|
+| 信息不足 | 返回 Investigate，继续收集 |
+| 需要架构设计 | 进入 Architect 阶段 |
+| 方案明确 | 直接进入 Document 阶段 |
+| 发现阻塞依赖 | 创建依赖 Issue，标记当前 Issue |
+| 问题过于复杂 | 建议拆分为多个 Issue |
+
+## 细化程度指南
+
+| Issue 类型 | 细化要求 |
+|------------|----------|
+| Epic | 必须包含架构设计、里程碑、子任务分解 |
+| Feature | 必须包含技术方案、风险评估、任务分解 |
+| Chore | 必须包含实施步骤、影响范围 |
+| Fix | 必须包含根因分析、修复方案、测试用例 |
+
+## 相关命令
+
+```bash
+# 查看 Issue 详情
+monoco issue show <ID>
+
+# 检查合规性
+monoco issue lint
+
+# 同步文件追踪
+monoco issue sync-files
+
+# 查看相关 Spike
+monoco spike list
+```
+
+## 与 flow_engineer 的关系
+
+此工作流与 `flow_engineer` 互补：
+- `issue-refine-workflow`: 关注 Issue 细化阶段，在开发前完成技术调查
+- `flow_engineer`: 关注代码实现阶段，执行 Investigate → Code → Test → Report → Submit
+
+细化阶段收集的信息将为 Engineer 阶段的 Investigate 提供重要输入。
+
+## Copilot 模式提示
+
+作为 AI Copilot，你应该：
+1. **主动探索**: 帮助开发者发现潜在问题和边界情况
+2. **提供对比**: 给出多个技术方案，分析优缺点
+3. **协助评估**: 帮助进行安全性、性能影响评估
+4. **提醒遗漏**: 检查是否有遗漏的关键信息或风险点

monoco/features/issue/resources/zh/{SKILL.md → skills/monoco_issue/SKILL.md}

@@ -1,6 +1,8 @@
 ---
 name: monoco-issue
 description: Monoco Issue System 的官方技能定义。将 Issue 视为通用原子 (Universal Atom)，管理 Epic/Feature/Chore/Fix 的生命周期。
+type: standard
+version: 1.0.0
 ---
 
 # 自我管理 (Monoco Issue System)

monoco/features/memo/resources/en/skills/monoco_memo/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: monoco-memo
+description: Lightweight memo system for quickly recording ideas, inspirations, and temporary notes. Distinguished from the formal Issue system.
+type: standard
+version: 1.0.0
+---
+
+# Monoco Memo
+
+Use this skill to quickly capture fleeting notes (fleeting ideas) without creating a formal Issue.
+
+## When to Use Memo vs Issue
+
+| Scenario | Use | Reason |
+|----------|-----|--------|
+| Temporary ideas, inspirations | **Memo** | No tracking needed, no completion status required |
+| Code snippets, link bookmarks | **Memo** | Quick record, organize later |
+| Meeting notes | **Memo** | Record first, then extract tasks |
+| Actionable work unit | **Issue** | Requires tracking, acceptance criteria, lifecycle |
+| Bug fix | **Issue** | Needs to record reproduction steps, verification results |
+| Feature development | **Issue** | Needs design, decomposition, delivery |
+
+> **Core Principle**: Memos record **ideas**; Issues handle **actionable tasks**.
+
+## Commands
+
+### Add Memo
+
+```bash
+monoco memo add "Your memo content"
+```
+
+Optional parameters:
+- `-c, --context`: Add context reference (e.g., `file:line`)
+
+Examples:
+```bash
+# Simple record
+monoco memo add "Consider using Redis cache for user sessions"
+
+# Record with context
+monoco memo add "Recursion here may cause stack overflow" -c "src/utils.py:42"
+```
+
+### View Memo List
+
+```bash
+monoco memo list
+```
+
+Displays all unarchived memos.
+
+### Open Memo File
+
+```bash
+monoco memo open
+```
+
+Opens the memo file in the default editor for organizing or batch editing.
+
+## Workflow
+
+```
+Idea flashes → monoco memo add "..." → Regular organization → Extract into Issue or archive
+```
+
+1. **Capture**: Use `monoco memo add` immediately when you have an idea
+2. **Organize**: Regularly (e.g., daily/weekly) run `monoco memo list` to review
+3. **Convert**: Transform valuable memos into formal Issues
+4. **Archive**: Remove from memos after processing
+
+## Best Practices
+
+1. **Keep concise**: Memos are quick notes, no detailed description needed
+2. **Convert timely**: Valuable ideas should be converted to Issue as soon as possible to avoid forgetting
+3. **Clean up regularly**: Memos are temporary, don't let them accumulate indefinitely
+4. **Use context**: When recording code-related ideas, use `-c` parameter to mark the location

monoco/features/memo/resources/en/skills/note_processing_workflow/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: note-processing-workflow
+description: Memo Note Processing Workflow (Flow Skill). Defines the standard operational process from capturing fleeting notes to organizing and archiving, ensuring effective management of ideas.
+type: flow
+domain: memo
+version: 1.0.0
+---
+
+# Note Processing Workflow
+
+Standardized workflow for Memo note processing, ensuring the "Capture → Process → Organize → Archive/Convert" process.
+
+## Workflow State Machine
+
+```mermaid
+stateDiagram-v2
+    [*] --> Capture: Idea flashes
+    
+    Capture --> Process: Regular organization
+    Capture --> Capture: Continue recording
+    
+    Process --> Organize: Classification completed
+    Process --> Archive: No value<br/>(archive directly)
+    
+    Organize --> Convert: Actionable
+    Organize --> Organize: Needs supplement<br/>(complete information)
+    Organize --> Archive: Pure reference<br/>(archive for storage)
+    
+    Convert --> [*]: Converted to Issue
+    
+    Archive --> [*]: Archiving completed
+```
+
+## Execution Steps
+
+### 1. Capture (Capture)
+
+- **Goal**: Quickly record fleeting ideas without interrupting current work
+- **Input**: Ideas, inspirations, code snippets, links
+- **Output**: Memo record
+- **Checkpoints**:
+  - [ ] Use `monoco memo add "content"`
+  - [ ] Keep it concise, no detailed description needed
+  - [ ] Add context (`-c file:line` if applicable)
+  - [ ] Do not interrupt current task flow
+
+### 2. Process (Processing)
+
+- **Goal**: Regularly review and classify Memos
+- **Strategy**: Regular organization (daily/weekly)
+- **Checkpoints**:
+  - [ ] Run `monoco memo list` to view all Memos
+  - [ ] Evaluate value of each Memo
+  - [ ] Classify: Actionable / Pure reference / No value
+  - [ ] Supplement missing information
+
+### 3. Organize (Organization)
+
+- **Goal**: Structured organization of valuable Memos
+- **Strategy**: Choose processing method based on type
+- **Checkpoints**:
+  - [ ] Add tags or categories to related Memos
+  - [ ] Merge similar Memos
+  - [ ] Complete vague records
+  - [ ] Set priority (if applicable)
+
+### 4. Archive/Convert (Archive or Convert)
+
+- **Goal**: Archive processed Memos or convert to Issue
+- **Checkpoints**:
+  - [ ] **Convert**: Convert actionable ideas to Issue
+    - Use `monoco issue create feature/chore/fix -t "title"`
+    - Reference original Memo in the Issue
+  - [ ] **Archive**: Archive pure reference content
+    - Move to knowledge base or documentation
+    - Remove from Memo list
+  - [ ] **Delete**: Delete Memos with no value directly
+
+## Decision Branches
+
+| Condition | Action |
+|-----------|--------|
+| Idea is actionable | Convert, create Issue |
+| Pure reference material | Archive, save to knowledge base |
+| No value/outdated | Delete, remove directly |
+| Information incomplete | Return to Organize, supplement information |
+
+## Compliance Requirements
+
+- **Required**: Memos are temporary, should not accumulate indefinitely
+- **Required**: Actionable ideas must be converted to Issue for tracking
+- **Recommended**: Process regularly (recommended weekly)
+- **Recommended**: Keep Memos concise, avoid lengthy discussions
+
+## Related Commands
+
+```bash
+# Add Memo
+monoco memo add "Consider using Redis cache for user sessions"
+
+# Memo with context
+monoco memo add "Recursion may cause stack overflow" -c "src/utils.py:42"
+
+# View all Memos
+monoco memo list
+
+# Edit Memo
+monoco memo open
+
+# Create Issue (convert Memo)
+monoco issue create feature -t "Implement Redis cache"
+```
+
+## Usage Scenarios
+
+| Scenario | Use Memo | Follow-up Processing |
+|----------|----------|---------------------|
+| Improvement suggestion during code review | `memo add "Refactoring suggestion: ..."` | Process → Convert to Issue |
+| Temporary idea during meeting | `memo add "Idea: ..."` | Process → Organize → Convert |
+| Useful code snippet | `memo add "Snippet: ..."` | Process → Archive to knowledge base |
+| Technical article link | `memo add "Read: https://..."` | Process → Archive |
+| Bug clue | `memo add "Possible Bug: ..."` | Process → Convert to Fix Issue |
+
+## Difference from Issue
+
+| Dimension | Memo | Issue |
+|-----------|------|-------|
+| Purpose | Record ideas | Track tasks |
+| Lifecycle | Temporary, needs regular cleanup | Formal, complete lifecycle |
+| Completion Criteria | Archived or converted | Acceptance criteria passed |
+| Complexity | Simple, one sentence | Detailed, with AC and Tasks |
+| Tracking | None | Complete tracking |
+
+## Best Practices
+
+1. **Record promptly**: Record immediately when ideas flash, avoid forgetting
+2. **Organize regularly**: Process Memo list at least once a week
+3. **Convert quickly**: Convert valuable ideas to Issue as soon as possible
+4. **Delete decisively**: Delete outdated or valueless Memos decisively
+5. **Keep concise**: Memos are quick notes, no detailed description needed

monoco/features/memo/resources/zh/{SKILL.md → skills/monoco_memo/SKILL.md}

@@ -1,6 +1,8 @@
 ---
 name: monoco-memo
 description: 轻量级备忘录系统，用于快速记录想法、灵感和临时笔记。与正式的 Issue 系统区分开来。
+type: standard
+version: 1.0.0
 ---
 
 # Monoco Memo (备忘录)

monoco/features/spike/resources/en/{SKILL.md → skills/monoco_spike/SKILL.md}

@@ -1,6 +1,8 @@
 ---
 name: monoco-spike
 description: Manage external reference repositories for research and learning. Provides read-only access to curated codebases.
+type: standard
+version: 1.0.0
 ---
 
 # Spike (Research)

monoco/features/spike/resources/en/skills/research_workflow/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: research-workflow
+description: Spike Research Workflow (Flow Skill). Defines the standard operational process from adding external repositories to knowledge extraction and archiving, ensuring effective management of external knowledge.
+type: flow
+domain: spike
+version: 1.0.0
+---
+
+# Research Workflow
+
+Standardized workflow for Spike research, ensuring the "Add → Sync → Analyze → Extract → Archive" process.
+
+## Workflow State Machine
+
+```mermaid
+stateDiagram-v2
+    [*] --> Add: Discover reference repository
+    
+    Add --> Sync: Configuration added
+    Add --> Add: Invalid URL<br/>(re-enter)
+    
+    Sync --> Analyze: Sync completed
+    Sync --> Sync: Sync failed<br/>(network/permission)
+    
+    Analyze --> Extract: Analysis completed
+    Analyze --> Analyze: Content mismatch<br/>(re-evaluate)
+    
+    Extract --> Archive: Knowledge extraction completed
+    
+    Archive --> [*]: Archiving completed
+```
+
+## Execution Steps
+
+### 1. Add (Add Repository)
+
+- **Goal**: Add external repository as reference
+- **Input**: Repository URL, reference purpose
+- **Output**: Configuration updated
+- **Checkpoints**:
+  - [ ] Verify repository URL is accessible
+  - [ ] Confirm repository is relevant to current project
+  - [ ] Run `monoco spike add <url>`
+  - [ ] Check `.monoco/config.yaml` is updated
+
+### 2. Sync (Synchronize)
+
+- **Goal**: Download or update reference repository content
+- **Checkpoints**:
+  - [ ] Run `monoco spike sync`
+  - [ ] Verify repository is cloned to `.references/<name>/`
+  - [ ] Check sync logs for errors
+  - [ ] Verify file permissions are correct (read-only)
+
+### 3. Analyze (Analysis)
+
+- **Goal**: Research the structure and content of reference repository
+- **Strategy**: Systematic browsing and marking
+- **Checkpoints**:
+  - [ ] Browse overall repository structure
+  - [ ] Identify modules relevant to current project
+  - [ ] Mark valuable code patterns
+  - [ ] Record architectural design highlights
+
+### 4. Extract (Knowledge Extraction)
+
+- **Goal**: Extract usable knowledge from reference repository
+- **Strategy**: Document valuable findings
+- **Checkpoints**:
+  - [ ] Extract key code snippets (without modifying original files)
+  - [ ] Record design patterns and best practices
+  - [ ] Create learning notes (using Memo or Issue)
+  - [ ] Annotate knowledge source (repository URL + Commit)
+
+### 5. Archive (Archiving)
+
+- **Goal**: Organize and archive research results
+- **Checkpoints**:
+  - [ ] Update project documentation, referencing the repository
+  - [ ] Create knowledge index (if needed)
+  - [ ] Run `monoco spike list` to verify status
+  - [ ] Periodically clean up references no longer needed
+
+## Decision Branches
+
+| Condition | Action |
+|-----------|--------|
+| Invalid URL | Return to Add, check URL format |
+| Sync failed | Check network, permissions, retry or skip |
+| Content not relevant | Remove from configuration, reselect |
+| Important pattern discovered | Create Issue, plan to introduce to project |
+
+## Compliance Requirements
+
+- **Prohibited**: Editing any files in `.references/`
+- **Required**: All external knowledge must be annotated with source
+- **Required**: Regular synchronization to get updates
+- **Recommended**: Only add high-quality, relevant repositories
+
+## Related Commands
+
+```bash
+# Add reference repository
+monoco spike add <url>
+
+# Sync all repositories
+monoco spike sync
+
+# List configured repositories
+monoco spike list
+
+# Record research findings
+monoco memo add "Discovery: {insight}" -c "spike:{repo_name}"
+```
+
+## Best Practices
+
+1. **Selective Choice**: Only add repositories highly relevant to the project
+2. **Read-only Access**: Treat `.references/` as external knowledge base, never modify
+3. **Regular Sync**: Run `monoco spike sync` monthly to get updates
+4. **Knowledge Transformation**: Transform learned patterns into actual project improvements

monoco/features/spike/resources/zh/{SKILL.md → skills/monoco_spike/SKILL.md}

@@ -1,6 +1,8 @@
 ---
 name: monoco-spike
 description: 管理用于研究和学习的外部参考仓库。提供对精选代码库的只读访问。
+type: standard
+version: 1.0.0
 ---
 
 # Spike (研究)

monoco_toolkit-0.3.10.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: monoco-toolkit
+Version: 0.3.10
+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
+Project-URL: Documentation, https://monoco.io/docs
+Project-URL: Issues, https://github.com/IndenScale/Monoco/issues
+Author-email: Monoco Team <dev@monoco.io>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-native,ai-agents,cli,kanban,monoco,task-management,workflow
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Groupware
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: prompt-toolkit>=3.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: sse-starlette>=1.6.0
+Requires-Dist: typer[all]>=0.9.0
+Requires-Dist: uvicorn[standard]>=0.20.0
+Requires-Dist: watchdog>=6.0.0
+Description-Content-Type: text/markdown
+
+# Monoco Distro
+
+[![Version](https://img.shields.io/pypi/v/monoco-toolkit)](https://pypi.org/project/monoco-toolkit/)
+[![License](https://img.shields.io/github/license/IndenScale/Monoco)](LICENSE)
+
+> **The Headless Operating System for Agentic Engineering.**
+>
+> Monoco is a **Linux-like Distribution** for AI Agents.
+> It provides the **Package Manager**, **Init System**, and **Policy Kit** that turns a raw LLM Kernel into a production-ready engineering workforce.
+
+---
+
+## 🐧 The "Distro" Metaphor
+
+Monoco is built on a clear separation of concerns, inspired by the Linux ecosystem:
+
+| Component   | In Linux      | In Monoco             | Responsibility                                                                                                             |
+| :---------- | :------------ | :-------------------- | :------------------------------------------------------------------------------------------------------------------------- |
+| **Kernel**  | Linux Kernel  | **Kimi CLI / Kosong** | The raw execution engine. Handles LLM prompts, tool execution, and process isolation.                                      |
+| **Distro**  | Ubuntu / Arch | **Monoco**            | The system manager. Orchestrates workflows, enforces policies, manages state (Issues), and installs capabilities (Skills). |
+| **Desktop** | GNOME / KDE   | **VSCode / Zed**      | The user interface. Connects to Monoco via standard protocols (LSP, ACP) to provide a visual experience.                   |
+
+## 🌟 Core Philosophy
+
+### 1. Headless & Protocol-First
+
+Monoco is designed to run silently in the background. It doesn't fight for your attention with a chat window. Instead, it exposes its state via **LSP (Language Server Protocol)** and **ACP (Agent Client Protocol)**, allowing your favorite IDEs to become "Agent-Native".
+
+### 2. Issue is the Unit of Work
+
+Just as `systemd` manages Units, Monoco manages **Issues**.
+An Issue is not just a text file; it is a stateful object that defines the lifecycle of a task. The Agent cannot "freelance"—it must be assigned to an active Issue.
+
+### 3. Governance as Code
+
+Monoco acts as the "Policy Kit" for your AI workforce.
+
+- **Guardrails**: Prevent destructive actions.
+- **Verification**: Enforce linting and tests before submission.
+- **Audit**: Log every decision and tool call.
+
+## 🚀 Quick Start
+
+### 1. Installation
+
+Install the Monoco Distro via pip:
+
+```bash
+pip install monoco-toolkit
+```
+
+### 2. Initialize System
+
+Turn your project into a Monoco-managed workspace:
+
+```bash
+monoco init
+```
+
+### 3. Sync Kernel
+
+Inject Monoco's policies into your Agent Kernel (e.g., Kimi CLI configuration):
+
+```bash
+monoco sync
+```
+
+### 4. Start a Session
+
+Launch the Monoco Daemon to begin orchestrating work:
+
+```bash
+monoco session start
+```
+
+## 🛠️ Tech Stack & Architecture
+
+- **Kernel Interface**: Python (Interfacing with Kimi/Kosong)
+- **Distro Logic**: Python (State Management, Issue Tracking)
+- **Protocols**: LSP / ACP (for IDE integration)
+- **Storage**: Local Filesystem (Markdown/YAML)
+
+## 🤝 Contributing
+
+Monoco is open-source. We are building the standard distribution for the Agentic era.
+
+## 📄 License
+
+MIT © [IndenScale](https://github.com/IndenScale)