monoco-toolkit 0.1.5__py3-none-any.whl

monoco/features/pty/server.py

@@ -0,0 +1,56 @@
+import logging
+import signal
+import sys
+from typing import Optional
+from pathlib import Path
+from contextlib import asynccontextmanager
+import uvicorn
+from fastapi import FastAPI
+from monoco.features.pty.router import router as pty_router, pty_manager
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    yield
+    # Shutdown
+    logging.info("Shutting down PTY manager and cleaning up sessions...")
+    pty_manager.close_all_sessions()
+
+def run_pty_server(host: str = "127.0.0.1", port: int = 3124, cwd: Optional[Path] = None):
+    """
+    Entry point for the 'monoco pty' command.
+    """
+    # Configure Logging
+    logging.basicConfig(level=logging.INFO)
+    
+    # Register a manual signal handler to ensure we catch termination even if uvicorn misses it
+    # or if we are stuck before uvicorn starts.
+    def handle_signal(signum, frame):
+        logging.info(f"Received signal {signum}, initiating shutdown...")
+        # We rely on uvicorn to handle the actual exit loop for SIGINT/SIGTERM usually,
+        # but having this log confirms propagation.
+        # If uvicorn is running, it should catch this first. 
+        # If not, we exit manually.
+        sys.exit(0)
+
+    # Note: Uvicorn overwrites SIGINT/SIGTERM handlers by default. 
+    # relying on lifespan is the standard "Uvicorn way".
+    
+    app = FastAPI(title="Monoco PTY Service", lifespan=lifespan)
+    app.include_router(pty_router)
+    
+    # If cwd is provided, we might want to set it as current process CWD
+    # so that new sessions default to it.
+    if cwd and cwd.exists():
+        import os
+        os.chdir(cwd)
+        logging.info(f"PTY Service Root: {cwd}")
+
+    logging.info(f"Starting Monoco PTY Service on ws://{host}:{port}")
+    try:
+        uvicorn.run(app, host=host, port=port)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        # Final safety net
+        pty_manager.close_all_sessions()

monoco/features/skills/__init__.py

@@ -0,0 +1 @@
+from .core import init

monoco/features/skills/core.py

@@ -0,0 +1,96 @@
+import os
+import re
+from pathlib import Path
+from typing import Dict, List, Any
+from rich.console import Console
+
+console = Console()
+
+def init(root: Path, resources: List[Dict[str, Any]]):
+    """
+    Initialize the Skills module.
+    
+    Args:
+        root: Project root directory.
+        resources: List of resource dicts from modules. 
+                   Expected format: 
+                   {
+                       "skills": { "name": "content" },
+                       "prompts": { "name": "content" } 
+                   }
+    """
+    skills_root = root / "Toolkit" / "skills"
+    skills_root.mkdir(parents=True, exist_ok=True)
+    
+    # 1. Write Skills
+    for res in resources:
+        if "skills" in res:
+            for name, content in res["skills"].items():
+                target_dir = skills_root / name
+                target_dir.mkdir(exist_ok=True)
+                target_file = target_dir / "SKILL.md"
+                # Idempotency: Overwrite if content is different? Or just always overwrite?
+                # User asked for "scaffold", implies creation. 
+                # Let's overwrite to ensure extensive "Repair" capability.
+                target_file.write_text(content, encoding="utf-8")
+                console.print(f"[dim]  - Scaffolding skill:[/dim] {name}")
+
+    # 2. Update Agent Docs
+    update_agent_docs(root, resources)
+
+def update_agent_docs(root: Path, resources: List[Dict[str, Any]]):
+    """
+    Inject prompts into AGENTS.md, GEMINI.md, CLAUDE.md.
+    """
+    target_files = ["AGENTS.md", "GEMINI.md", "CLAUDE.md"]
+    
+    # Aggregate Prompts
+    aggregated_prompt = "\n\n".join([
+        res["prompts"][name] 
+        for res in resources 
+        if "prompts" in res 
+        for name in res["prompts"]
+    ])
+    
+    injection_content = f"""
+## Monoco Toolkit
+
+The following tools and skills are available in this environment.
+
+{aggregated_prompt}
+"""
+
+    for filename in target_files:
+        _inject_section(root / filename, injection_content)
+
+def _inject_section(file_path: Path, content: str):
+    if not file_path.exists():
+        # Create if not exists? User said "Edit AGENTS.md...", implies existence.
+        # But if we init in a fresh repo, maybe we should create them?
+        # Let's create if missing.
+        file_path.write_text(f"# Project Guidelines\n{content}", encoding="utf-8")
+        console.print(f"[green]✔[/green] Created {file_path.name}")
+        return
+
+    original_content = file_path.read_text(encoding="utf-8")
+    
+    # Regex to find existing section
+    # Matches ## Monoco Toolkit ... until next ## or End of String
+    pattern = r"(## Monoco Toolkit.*?)(\n## |\Z)"
+    
+    # Check if section exists
+    if re.search(pattern, original_content, re.DOTALL):
+        # Replace
+        new_content = re.sub(pattern, f"{content.strip()}\n\n\\2", original_content, flags=re.DOTALL)
+        if new_content != original_content:
+            file_path.write_text(new_content, encoding="utf-8")
+            console.print(f"[green]✔[/green] Updated {file_path.name}")
+        else:
+            console.print(f"[dim]  - {file_path.name} is up to date.[/dim]")
+    else:
+        # Append
+        with open(file_path, "a", encoding="utf-8") as f:
+            if not original_content.endswith("\n"):
+                f.write("\n")
+            f.write(content)
+        console.print(f"[green]✔[/green] Appended to {file_path.name}")

monoco/features/spike/commands.py

@@ -0,0 +1,110 @@
+import typer
+from pathlib import Path
+from rich.console import Console
+
+from monoco.core.config import get_config
+from . import core
+
+app = typer.Typer(help="Spike & Repo Management.")
+console = Console()
+
+@app.command("init")
+def init():
+    """Initialize the Spike environment (gitignore setup)."""
+    config = get_config()
+    root_dir = Path(config.paths.root)
+    spikes_dir_name = config.paths.spikes
+    
+    core.ensure_gitignore(root_dir, spikes_dir_name)
+    
+    # Create the directory
+    (root_dir / spikes_dir_name).mkdir(exist_ok=True)
+    
+    console.print(f"[green]✔[/green] Initialized Spike environment. Added '{spikes_dir_name}/' to .gitignore.")
+
+@app.command("add")
+def add_repo(
+    url: str = typer.Argument(..., help="Git Repository URL"),
+):
+    """Add a new research repository."""
+    config = get_config()
+    root_dir = Path(config.paths.root)
+    
+    # Infer name from URL
+    # e.g., https://github.com/foo/bar.git -> bar
+    # e.g., git@github.com:foo/bar.git -> bar
+    name = url.split("/")[-1]
+    if name.endswith(".git"):
+        name = name[:-4]
+        
+    core.update_config_repos(root_dir, name, url)
+    console.print(f"[green]✔[/green] Added repo [bold]{name}[/bold] ({url}) to configuration.")
+    console.print("Run [bold]monoco spike sync[/bold] to download content.")
+
+@app.command("remove")
+def remove_repo(
+    name: str = typer.Argument(..., help="Repository Name"),
+    force: bool = typer.Option(False, "--force", "-f", help="Force delete physical directory without asking"),
+):
+    """Remove a repository from configuration."""
+    config = get_config()
+    root_dir = Path(config.paths.root)
+    spikes_dir = root_dir / config.paths.spikes
+    
+    if name not in config.project.spike_repos:
+        console.print(f"[yellow]![/yellow] Repo [bold]{name}[/bold] not found in configuration.")
+        return
+
+    # Remove from config
+    core.update_config_repos(root_dir, name, "", remove=True)
+    console.print(f"[green]✔[/green] Removed [bold]{name}[/bold] from configuration.")
+    
+    target_path = spikes_dir / name
+    if target_path.exists():
+        if force or typer.confirm(f"Do you want to delete the directory {target_path}?", default=False):
+            core.remove_repo_dir(spikes_dir, name)
+            console.print(f"[gray]✔[/gray] Deleted directory {target_path}.")
+        else:
+            console.print(f"[gray]ℹ[/gray] Directory {target_path} kept.")
+
+@app.command("sync")
+def sync_repos():
+    """Sync (Clone/Pull) all configured repositories."""
+    # Force reload config to get latest updates
+    config = get_config()
+    # Note: get_config is a singleton, so for 'add' then 'sync' in same process, 
+    # we rely on 'add' writing to disk and us reading from memory? 
+    # Actually, if we run standard CLI "monoco spike add" then "monoco spike sync", 
+    # they are separate processes, so config loads fresh.
+    
+    root_dir = Path(config.paths.root)
+    spikes_dir = root_dir / config.paths.spikes
+    spikes_dir.mkdir(exist_ok=True)
+    
+    repos = config.project.spike_repos
+    
+    if not repos:
+        console.print("[yellow]No repositories configured.[/yellow] Use 'monoco spike add <url>' first.")
+        return
+        
+    console.print(f"Syncing {len(repos)} repositories...")
+    
+    for name, url in repos.items():
+        core.sync_repo(root_dir, spikes_dir, name, url)
+        
+    console.print("[green]✔[/green] Sync complete.")
+
+# Alias for list (showing configured repos) could be useful but not strictly asked for.
+# Let's add a simple list command to see what we have.
+@app.command("list")
+def list_repos():
+    """List configured repositories."""
+    config = get_config()
+    repos = config.project.spike_repos
+    
+    if not repos:
+        console.print("[yellow]No repositories configured.[/yellow]")
+        return
+        
+    for name, url in repos.items():
+        console.print(f"- [bold]{name}[/bold]: {url}")

monoco/features/spike/core.py

@@ -0,0 +1,154 @@
+import os
+import shutil
+import subprocess
+import yaml
+from pathlib import Path
+from typing import Dict, Optional, List, Any
+from rich.console import Console
+
+from monoco.core.config import get_config
+
+console = Console()
+
+def run_git_command(cmd: List[str], cwd: Path) -> bool:
+    """Run a git command in the specified directory."""
+    try:
+        subprocess.run(
+            cmd,
+            cwd=cwd,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        return True
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Git Error:[/red] {' '.join(cmd)}\n{e.stderr}")
+        return False
+    except FileNotFoundError:
+        console.print("[red]Error:[/red] git command not found.")
+        return False
+
+def get_config_file_path(root: Path) -> Path:
+    """Determine the config file to update."""
+    # Priority 1: .monoco/config.yaml
+    hidden = root / ".monoco" / "config.yaml"
+    if hidden.exists():
+        return hidden
+    
+    # Priority 2: monoco.yaml
+    visible = root / "monoco.yaml"
+    if visible.exists():
+        return visible
+    
+    # Default to .monoco/config.yaml for new files
+    hidden.parent.mkdir(exist_ok=True)
+    return hidden
+
+def update_config_repos(root: Path, repo_name: str, repo_url: str, remove: bool = False):
+    """Update the repos list in the config file."""
+    config_path = get_config_file_path(root)
+    
+    data = {}
+    if config_path.exists():
+        try:
+            with open(config_path, "r") as f:
+                data = yaml.safe_load(f) or {}
+        except Exception:
+            data = {}
+            
+    # Ensure structure exists
+    if "project" not in data:
+        data["project"] = {}
+    if "spike_repos" not in data["project"]:
+        data["project"]["spike_repos"] = {}
+        
+    if remove:
+        if repo_name in data["project"]["spike_repos"]:
+            del data["project"]["spike_repos"][repo_name]
+    else:
+        data["project"]["spike_repos"][repo_name] = repo_url
+        
+    with open(config_path, "w") as f:
+        yaml.dump(data, f, sort_keys=False, default_flow_style=False)
+
+def ensure_gitignore(root: Path, target_dir_name: str):
+    """Ensure the target directory is in .gitignore."""
+    gitignore = root / ".gitignore"
+    if not gitignore.exists():
+        gitignore.write_text(f"{target_dir_name}/\n")
+        return
+
+    content = gitignore.read_text()
+    if f"{target_dir_name}/" not in content and f"{target_dir_name}" not in content:
+        # Avoid redundant newlines if file ends with one
+        prefix = "\n" if content and not content.endswith("\n") else ""
+        with open(gitignore, "a") as f:
+            f.write(f"{prefix}{target_dir_name}/\n")
+
+def sync_repo(root: Path, spikes_dir: Path, name: str, url: str):
+    """Clone or Pull a repo."""
+    target_path = spikes_dir / name
+    
+    if target_path.exists() and (target_path / ".git").exists():
+        console.print(f"Updating [bold]{name}[/bold]...")
+        run_git_command(["git", "pull"], cwd=target_path)
+    else:
+        # If dir exists but not a git repo, warn or error? 
+        # For safety, if non-empty and not git, skip or error.
+        if target_path.exists() and any(target_path.iterdir()):
+             console.print(f"[yellow]Skipping {name}:[/yellow] Directory exists and is not empty, but not a git repo.")
+             return
+
+        console.print(f"Cloning [bold]{name}[/bold]...")
+        target_path.mkdir(parents=True, exist_ok=True)
+        run_git_command(["git", "clone", url, "."], cwd=target_path)
+
+def remove_repo_dir(spikes_dir: Path, name: str):
+    """Physically remove the repo directory."""
+    target_path = spikes_dir / name
+
+    if target_path.exists():
+        shutil.rmtree(target_path)
+
+SKILL_CONTENT = """---
+name: git-repo-spike
+description: Manage external Git repositories as References in `.reference/`.
+---
+
+# Git Repo Spike (Reference Management)
+
+This skill normalizes how we introduce external code repositories.
+
+## Core Principles
+1. **Read-Only**: Code in `.reference/` is for reference only.
+2. **Isolation**: All external repos sit within `.reference/`.
+3. **VCS Hygiene**: `.reference/` is gitignored. We track the intent to clone, not the files.
+
+## Workflow
+1. **Add**: `monoco spike add <url>`
+2. **Sync**: `monoco spike sync` (Clones/Pulls all repos)
+3. **Remove**: `monoco spike remove <name>`
+"""
+
+PROMPT_CONTENT = """### Spike (Research)
+Manage external reference repositories.
+- **Add Repo**: `monoco spike add <url>` (Available in `.reference/<name>` for reading)
+- **Sync**: `monoco spike sync` (Run to download content)
+- **Constraint**: Never edit files in `.reference/`. Treat them as read-only external knowledge."""
+
+def init(root: Path, spikes_dir_name: str):
+    """Initialize Spike environment."""
+    ensure_gitignore(root, spikes_dir_name)
+    (root / spikes_dir_name).mkdir(exist_ok=True)
+
+def get_resources() -> Dict[str, Any]:
+    return {
+        "skills": {
+            "git-repo-spike": SKILL_CONTENT
+        },
+        "prompts": {
+            "spike": PROMPT_CONTENT
+        }
+    }
+

monoco/main.py

@@ -0,0 +1,110 @@
+import os
+import typer
+from typing import Optional
+from monoco.core.output import print_output
+
+app = typer.Typer(
+    name="monoco",
+    help="Monoco Agent Native Toolkit",
+    add_completion=False,
+    no_args_is_help=True
+)
+
+
+def version_callback(value: bool):
+    if value:
+        import importlib.metadata
+        try:
+            version = importlib.metadata.version("monoco-toolkit")
+        except importlib.metadata.PackageNotFoundError:
+            version = "unknown"
+        print(f"Monoco Toolkit v{version}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    version: Optional[bool] = typer.Option(
+        None, "--version", "-v", help="Show version and exit", callback=version_callback, is_eager=True
+    ),
+):
+    """
+    Monoco Toolkit - The sensory and motor system for Monoco Agents.
+    """
+    # Capture command execution
+    from monoco.core.telemetry import capture_event
+    if ctx.invoked_subcommand:
+        capture_event("cli_command_executed", {"command": ctx.invoked_subcommand})
+
+from monoco.core.setup import init_cli
+app.command(name="init")(init_cli)
+
+@app.command()
+def info():
+    """
+    Show toolkit information and current mode.
+    """
+    from pydantic import BaseModel
+    from monoco.core.config import get_config
+    
+    settings = get_config()
+
+    class Status(BaseModel):
+        version: str
+        mode: str
+        root: str
+        project: str
+
+    mode = "Agent (JSON)" if os.getenv("AGENT_FLAG") == "true" else "Human (Rich)"
+    
+    import importlib.metadata
+    try:
+        version = importlib.metadata.version("monoco-toolkit")
+    except importlib.metadata.PackageNotFoundError:
+        version = "unknown"
+
+    status = Status(
+        version=version,
+        mode=mode,
+        root=os.getcwd(),
+        project=f"{settings.project.name} ({settings.project.key})"
+    )
+    
+    print_output(status, title="Monoco Toolkit Status")
+    
+    if mode == "Human (Rich)":
+        print_output(settings, title="Current Configuration")
+
+# Register Feature Modules
+# Register Feature Modules
+from monoco.features.issue import commands as issue_cmd
+from monoco.features.spike import commands as spike_cmd
+from monoco.features.i18n import commands as i18n_cmd
+from monoco.features.config import commands as config_cmd
+
+app.add_typer(issue_cmd.app, name="issue", help="Manage development issues")
+app.add_typer(spike_cmd.app, name="spike", help="Manage research spikes")
+app.add_typer(i18n_cmd.app, name="i18n", help="Manage documentation i18n")
+app.add_typer(config_cmd.app, name="config", help="Manage configuration")
+
+from monoco.daemon.commands import serve
+app.command(name="serve")(serve)
+
+@app.command()
+def pty(
+    host: str = "127.0.0.1",
+    port: int = 3124,
+    cwd: Optional[str] = None
+):
+    """
+    Start the Monoco PTY Daemon (WebSocket).
+    """
+    from monoco.features.pty.server import run_pty_server
+    from pathlib import Path
+    
+    path = Path(cwd) if cwd else None
+    run_pty_server(host, port, path)
+
+if __name__ == "__main__":
+    app()

monoco_toolkit-0.1.5.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: monoco-toolkit
+Version: 0.1.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
+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: Harnessing AI Agents
+
+> **The control interface between raw AI velocity and human information bandwidth.**
+
+Production in the LLM era is exploding along a vertical curve. A single AI agent can work 24/7, generating massive amounts of intermediate data that far exceeds the biological information bandwidth of a human supervisor. When one agent becomes a hundred, the bottleneck is no longer "intelligence"—it is "command and control."
+
+**Monoco is the Cockpit.**
+
+It doesn't just "run" agents; it "encapsulates" them. It provides a deterministic barrier between the chaotic, raw execution power of LLMs and the rigorous, finite decision bandwidth of human engineers. It ensures that every agentic action eventually collapses into the outcome you intended.
+
+## Workflow: Plan - Execute - Review - Archive
+
+Monoco channels agent execution into a clear cycle:
+
+1. **Plan**: Decompose complex missions through **Project → Epic → Feature** hierarchies into executable atomic units.
+2. **Execute**: Agents work autonomously based on acceptance criteria defined in Issues, with all intermediate states persisted as structured files.
+3. **Review**: Humans monitor progress through the Kanban dashboard, intervening only at critical decision points.
+4. **Archive**: Completed tasks automatically transition to archived states, forming a traceable project history.
+
+## The Control Matrix
+
+- **Task Anchors (Issues)**: Define missions via structured files, setting clear boundaries and acceptance criteria for agents.
+- **Deterministic Interface (CLI)**: Acts as a sensory extension for LLMs, providing them with structured perception of project state and eliminating hallucinated guesses.
+- **Mission Dashboard (Kanban)**: A high-fidelity visual console that allows humans to audit tasks and transition states with minimal cognitive load.
+
+## Quick Start
+
+### 1. Install the Control Suite
+
+```bash
+pip install monoco-toolkit
+```
+
+### 2. Initialize the Workflow
+
+```bash
+monoco init
+```
+
+### 3. Take Control
+
+Start the backend control hub:
+
+```bash
+monoco serve
+```
+
+Then, launch the visual mission dashboard from anywhere:
+
+```bash
+npx @monoco-io/kanban
+```
+
+Visit `http://localhost:3123` (or the URL displayed in your terminal) to enter your cockpit.
+
+---
+
+_"Cars are made to drive, not to fix."_

monoco_toolkit-0.1.5.dist-info/RECORD

@@ -0,0 +1,36 @@
+monoco/main.py,sha256=_16blpwjqnSsmahwj9lJ6Cgm_6OVYw9BsdORepY3zX8,3058
+monoco/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monoco/core/config.py,sha256=oiWB4bYkLGNhV9J3nGHdYjnVIux0gi8u9oYEpcvanpA,4768
+monoco/core/git.py,sha256=Qy5VjCKe0Y1y0rjqYULxT_viS7S4phTljf8hkd9DA8Q,6424
+monoco/core/output.py,sha256=CK8efvj0Q-pWrcJMdXwbuCyfsykWZ_pen9YWuDsivXQ,3192
+monoco/core/setup.py,sha256=qbMh6LV5wvXNYwquzxpmf3JZAoNDcwLClnNZ2QXPajs,8406
+monoco/core/telemetry.py,sha256=DZQGOhvpe0XL34RCDaTZEUhmkD4abBTZumZJQlALzpY,2923
+monoco/core/workspace.py,sha256=pFMC2culomxOF6Q1XqpEHCB8WjEEPBxKObUsOVpIG-E,1306
+monoco/daemon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monoco/daemon/app.py,sha256=RdNVjaB1JJUJ3_qCfKzBWyTRoNZV10KsBxoMHG--To8,12819
+monoco/daemon/commands.py,sha256=dN4D8ca0vPjj0WyjCSs8senneta1afm_bnNYv_kmGlU,1125
+monoco/daemon/models.py,sha256=DqhR8_t0Oz1Tptqkw9KGZMgvPyL8mvb01aFdbmKqi4M,812
+monoco/daemon/reproduce_stats.py,sha256=Q_zAj0Yj8l-77QDdtsLz1kWr68HeO7f1T6xC6VP43Vo,1261
+monoco/daemon/services.py,sha256=ExSPd2J4QtzrHPG_sYjNMDtA3p_3xmQXo_gfL-2oIUY,9151
+monoco/daemon/stats.py,sha256=r-L0k6CdxkAkwLZV3V-jW7PldB9S3uNklQGLCEKA3Sc,4563
+monoco/features/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monoco/features/config/commands.py,sha256=BySoGkIYia6RTsouDREAyjLV14n-_sZnInzPDlPdYCo,2139
+monoco/features/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monoco/features/i18n/commands.py,sha256=M_T8Ddw54p42wsZIowFjBq72mXKLsppzBRcHUByfhls,4816
+monoco/features/i18n/core.py,sha256=recjfNhJA2xdqFUMIivZ2omQZEzbgXJ1QvhjmvEDj24,5957
+monoco/features/issue/commands.py,sha256=w89KS19pJfMRzbIMIECQatalvPe4Q5rT8vSPfUnRQik,29448
+monoco/features/issue/core.py,sha256=iX-p7fTQUThKcAYOzlbBHldqG5naJV012cBvIxYIeFA,43778
+monoco/features/issue/linter.py,sha256=ZMNpp_0ehbzBMYROfPtCr4O4JL8mhdO9L0F3EAi96lE,7657
+monoco/features/issue/models.py,sha256=sepGxdgvRFRSc4tyvcUB9oXFBkDyS9_g0bGZEaE8Eq8,4970
+monoco/features/pty/core.py,sha256=eM1EvHQrgExSnatO15pyfhh1VZoz0BBTfNYdXqG8HZ8,5711
+monoco/features/pty/router.py,sha256=7h80EPpOuE7hX5ifkxkzffcLZGecd5X8OmNvOji5ToI,5078
+monoco/features/pty/server.py,sha256=kw2csMZ_R4_Xx6ta2dbznWtgNZLfrWOAkMp8NjlZYBc,1920
+monoco/features/skills/__init__.py,sha256=L8YNGPWyyFWq5WqNossfeB0AKHJF_omrn1VzJBrRFcM,23
+monoco/features/skills/core.py,sha256=mpd0Cq-k2MvHRTPq9saFvZgYXUBGJ9pnK5lUmzUfZbY,3418
+monoco/features/spike/commands.py,sha256=BpwYYIpihmezJACOxgQojsCM7RwXqL0_EB6wCl--Mm8,3947
+monoco/features/spike/core.py,sha256=FSlO3Lhz49_nyFp68TpxBdkFKksShz5S33Qxh74ZFpY,5150
+monoco_toolkit-0.1.5.dist-info/METADATA,sha256=1j6huqrvTPN4rMnw_rdB8RweTuvf85jrlCrgP2HpKTY,3743
+monoco_toolkit-0.1.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+monoco_toolkit-0.1.5.dist-info/entry_points.txt,sha256=iYj7FWYBdtClU15-Du1skqD0s6SFSIhJvxJ29VWp8ng,43
+monoco_toolkit-0.1.5.dist-info/licenses/LICENSE,sha256=ACAGGjV6aod4eIlVUTx1q9PZbnZGN5bBwkSs9RHj83s,1071
+monoco_toolkit-0.1.5.dist-info/RECORD,,

monoco_toolkit-0.1.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

monoco_toolkit-0.1.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+monoco = monoco.main:app