monoco-toolkit 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

{monoco_toolkit-0.2.5.dist-info → monoco_toolkit-0.2.7.dist-info}/RECORD

@@ -1,18 +1,18 @@
-monoco/main.py,sha256=MhS-vdL05KGZeEYU4XNbJEFXuNyRUyTFiZ1hrmxNCMs,6098
+monoco/main.py,sha256=wWOtB54RB4_opq_DuRQyEStAYbJHgGCZfQglUup6q28,5370
 monoco/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/cli/project.py,sha256=w4oUWzOV42qh34g4klyzZfTUg6ux0oEdSinMCzmhH3E,2786
 monoco/cli/workspace.py,sha256=vhRsbjgO6ek6PWYdmhk9EeYW_xWRV196yl7-xPfcRAI,1305
 monoco/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monoco/core/config.py,sha256=WJvYtLCLG4sRYcg46-fD7D5Uv32Ex1KQXD-i257hZGs,10781
+monoco/core/config.py,sha256=UpP6OE3wex8ZesnMZVZKPRy1peHrjq8nXv_BVtZzNIk,12105
 monoco/core/execution.py,sha256=rySL0ueJvTEQ1JhdpumsNBQHJpj08nfaHQMlX-1uh6k,1846
 monoco/core/feature.py,sha256=oAtQWUHMuqIFbq2gj8sPfYBlJZvMMXZqyUlCMrIVGUE,2007
 monoco/core/git.py,sha256=i_NKT9_n57S9EKeb8kF2yTEdw70FZ88-lpMqW4lzVds,8228
 monoco/core/injection.py,sha256=4BuQ5RVozyU99uSOzPwgc6MFMZUcECerTik5lF39I9A,7078
-monoco/core/integrations.py,sha256=QRZjCwHb6xudIoxrFSE_gvQKNWlIOXGn-SxZelqqrWw,7667
-monoco/core/lsp.py,sha256=aif3iMgfpyCrBL1qlbakJerjT--ePwoWnRa-5CCMMkY,1844
-monoco/core/output.py,sha256=9JbCxqxHZlviNJXpUorGVxv_gAn4q72FPgjwBQrPiCI,3502
+monoco/core/integrations.py,sha256=MGw6dCipX2S5GtnboFwVxpkuWMGa_I6T9s0owsIjU4o,7885
+monoco/core/lsp.py,sha256=23OxtVomvvE0GgAbdw_8-DclIac1SzjJGt8urbPKXEA,2006
+monoco/core/output.py,sha256=S5jbOBRuLleBPfypS5nUUoNIUAdub4zJO63RePLb0LU,3787
 monoco/core/registry.py,sha256=xix21TDeJgRiZ2kvHitnac4RsqMdp1aERpYGSrwfIpY,1180
-monoco/core/setup.py,sha256=gx_jrSlRpHxIisuA3JUG-dnHTzIpq4Jq5zz_5Y2MkNY,9313
+monoco/core/setup.py,sha256=5fAsj4HZAC1sG-pEn5hKTZ6JsCAqNa8-eWOs739wpqs,9657
 monoco/core/skills.py,sha256=5qK-0YlOnNQLqyo6-T4GVBrkjsbrszb5ugXeXRRcQ00,16597
 monoco/core/state.py,sha256=KlmOn0KXO8g9S_KUIrUylAKdBpyH_1AOBvrYSj_khdE,1884
 monoco/core/sync.py,sha256=s0qQ5PsVn_IWGWUNThdvNFS-CncztDzsTM3QLupC6Og,8514
@@ -20,13 +20,13 @@ monoco/core/telemetry.py,sha256=DZQGOhvpe0XL34RCDaTZEUhmkD4abBTZumZJQlALzpY,2923
 monoco/core/workspace.py,sha256=0RWx8H_Kx56TYVrAURTSJW4aWOUylXofkvXBhRNjP_E,3074
 monoco/core/agent/__init__.py,sha256=tBCm6PDqPFo81yO949nW897INjl7ot46CPup9IrXExE,108
 monoco/core/agent/action.py,sha256=HpOLzp-mttJY0SDVbRlstDVqjFKozIAdjQdJ4Gp3xiY,5161
-monoco/core/agent/adapters.py,sha256=3M6-8uz_WOxXY1bMdu3epQ15v9dc-8Bolq00-mwLxwM,3517
+monoco/core/agent/adapters.py,sha256=s8dzeXZY-m1pb8re5U5O1ED4d6MT9WNFWIeSpHBcmRg,4391
 monoco/core/agent/protocol.py,sha256=E7y_i2JzYGpzSCRCUIuzu1ATav-Xu1K01ka6Zncm4-o,831
 monoco/core/agent/state.py,sha256=sRav6uwkXao8yPl08CEB-cqK1EfiDyMnVxoSYxvYcis,3523
 monoco/core/resources/en/AGENTS.md,sha256=3TpCLNC1s_lIbDfJJBRmmROMoy9sZXu8BOag8M9NXI0,327
 monoco/core/resources/en/SKILL.md,sha256=1PrBqCgjDxT1LMSeu11BzlMhfboo_UlgZxdzBm7Tp9c,2161
 monoco/core/resources/zh/AGENTS.md,sha256=pGQOLt8mcRygJotd5oC8l9604hikQoUiS99QsHCe-UM,298
-monoco/core/resources/zh/SKILL.md,sha256=YlO0OO-yxwtZG4pMwTMAVaZ5-tfwysNYzLJNdULLHiE,1896
+monoco/core/resources/zh/SKILL.md,sha256=8py8tD7s23cw2srKFnTjLO_miyuGXb3NLyEbk5gchqA,1886
 monoco/daemon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/daemon/app.py,sha256=I_BWs4WcJoTobssFKRBlAcD2CRnJtr6EPlFoGB5Hy-Y,15586
 monoco/daemon/commands.py,sha256=dN4D8ca0vPjj0WyjCSs8senneta1afm_bnNYv_kmGlU,1125
@@ -35,8 +35,6 @@ monoco/daemon/reproduce_stats.py,sha256=Q_zAj0Yj8l-77QDdtsLz1kWr68HeO7f1T6xC6VP4
 monoco/daemon/services.py,sha256=dMhy2ddzGtBBWTGtI14R-2aikENAgPsphxDkno1JAPU,5377
 monoco/daemon/stats.py,sha256=r-L0k6CdxkAkwLZV3V-jW7PldB9S3uNklQGLCEKA3Sc,4563
 monoco/features/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monoco/features/agent/commands.py,sha256=p2wc05pzEeyPEYpfkHo2-X89IdnDp7hO1LCc2JBTCuI,5898
-monoco/features/agent/doctor.py,sha256=qqUu_rUjVp7ur1sYpL4VSpw8vwbwbjvXAFvXQP-lbNQ,924
 monoco/features/config/commands.py,sha256=PQaSq81zH4h8d1bFa4B2ANSXSdyjBFqVm_nBvEq1rNE,4889
 monoco/features/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/features/i18n/adapter.py,sha256=M9iSEKykEiUe1YobHKmvfEjv7x7KgGuh-6yhgUJuN_s,973
@@ -45,33 +43,41 @@ monoco/features/i18n/core.py,sha256=s0r-48yMxrIrpWNX7r8JhtGX4X-Kd1P1bDAgNyluQ24,
 monoco/features/i18n/resources/en/AGENTS.md,sha256=zzuF7BW6x8Mj6LZZmeM6wTbG5CSCDMShf4rwtN7XITg,197
 monoco/features/i18n/resources/en/SKILL.md,sha256=Z8fAAqeMvpLDw1D_9AzZIykS5-HLVM9nnlRZLWBTPqM,2203
 monoco/features/i18n/resources/zh/AGENTS.md,sha256=lKkwLLCADRH7UDq9no4eQY2sRfJrb64JoZ_HNved8vA,175
-monoco/features/i18n/resources/zh/SKILL.md,sha256=y2UuwhZmCBy0pXGxWLNrhxb94zcNfGEMBA_imJgDqVg,1894
+monoco/features/i18n/resources/zh/SKILL.md,sha256=Wynk7zVBW7CO0_6AEQNUvlD_3eMW_7EPnzEn9QUaiDs,1884
 monoco/features/issue/adapter.py,sha256=Y-ghwRoSEgm_A-cqY8Un-5srxydXdb9ytlKHLm89eJQ,1265
-monoco/features/issue/commands.py,sha256=LjBKplstvSAPxQ-PSvxe1y2sP-6wPrc8O9wGiXNpH_E,32189
-monoco/features/issue/core.py,sha256=cAPmJVLMCPMkfMe2WNZVdSQr0Pg6s8sN-SMU7LlhtR0,47108
-monoco/features/issue/linter.py,sha256=g98_NKXZFGw0ewBX7g-80CAKvPE0zdazQw1hT2uFtcU,11117
+monoco/features/issue/commands.py,sha256=7QMklWteteG2eO1ERe2V7oFjoSEhz3jjEvD6_4ySpug,34479
+monoco/features/issue/core.py,sha256=s1K1FWdsOq1-pBQ8HTayg1o0dK9_JWHXIcw2wBd_WpM,47155
+monoco/features/issue/linter.py,sha256=-S3-DK0HKP_3EhSC69za8MyB-bVU4vOkNGM_Ajmjxoo,12056
 monoco/features/issue/migration.py,sha256=9gtgFi1V1pzwXo0-H4cIoBvSBERIWopXLCB4oSxTQLc,4715
-monoco/features/issue/models.py,sha256=pMBLvcGrqO0tpf-7TMnt9VAIzgkq5P79-hqfH8T_EBw,5044
+monoco/features/issue/models.py,sha256=waj5JDzL3UPs2qW4lv6c7v_5aSYEDWZftLkwS2U70RA,5778
 monoco/features/issue/monitor.py,sha256=QEN0mqZ3tKwBfMjN87-LdrVoIEe0prA-uMHOBGy1VZk,3476
-monoco/features/issue/validator.py,sha256=oFKl3xG0tM0A33LVCHoLbsCK5PE-GlTTfJNcWnVDOPY,11373
+monoco/features/issue/validator.py,sha256=6Q8LyjGpHXOf97q0-3bXvrWFqk7iO6fHhoGemkPTbps,17172
+monoco/features/issue/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monoco/features/issue/domain/lifecycle.py,sha256=-WreIDCeEQPjD82Q4wJMs_S5-9SQHCvGlPgtMllvXGw,4943
+monoco/features/issue/domain/models.py,sha256=pjeb_Lp0zykNzAfrRma26IMkdlxYDQ0IdvNmM_7tepU,5720
+monoco/features/issue/domain/parser.py,sha256=HfJh9uBN7Q7KyeXz1tk3tBjszu8ffStfZf9IS27v0K8,8770
+monoco/features/issue/domain/workspace.py,sha256=AOv7H_he39UnYplCaEex6mdFgpAlGk6T8cDMxKwQLz0,3833
+monoco/features/issue/engine/__init__.py,sha256=bWONZnIb0IkAhw09_pMbyqrDh-oUOLTrNvlQfypHXYw,785
+monoco/features/issue/engine/config.py,sha256=BhTw9S8Oe10P1VfdLN64Nk0Woj613dHwfHiX87_AgJo,5762
+monoco/features/issue/engine/machine.py,sha256=8wr5txLlzv0QO2sAlPl7JSPN-VkxJUpRNK25F7L7DVI,7530
+monoco/features/issue/engine/models.py,sha256=u8Z7ilB702Jj6Imv4_vXpP8QTSWEnQdPxv8JA_9g1GU,579
+monoco/features/issue/lsp/__init__.py,sha256=8bl8-WzSj3C4SkPKgVGnCeyemmvHVWBsuMZsJuJggG8,77
+monoco/features/issue/lsp/definition.py,sha256=Y4dX7MmrEfYbWuh85W0djwUj_qed7cDpGadtiXEZDh4,3107
 monoco/features/issue/resources/en/AGENTS.md,sha256=OjEnkXCqwfMArJfJQhldrQYXqoregfGthyhJeyx7MPw,715
 monoco/features/issue/resources/en/SKILL.md,sha256=p0vhVpe3xLKg0iXSNofoLNvsq8j2pmv5CD1B2mUeIGk,2732
 monoco/features/issue/resources/zh/AGENTS.md,sha256=2MLIZ5-i-oBnl7_YAZBBoKkNqANpHj73iw18QQbSm5c,759
-monoco/features/issue/resources/zh/SKILL.md,sha256=_aXDThhsJag9OLK2X5LRVhaFyMcl4DcZvcSj1_UUkx8,3828
-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/issue/resources/zh/SKILL.md,sha256=vT1-Cp5ENLrpmCuv14D5xdRGQh3ferL6zCPLSRfsoE8,3816
 monoco/features/skills/__init__.py,sha256=L8YNGPWyyFWq5WqNossfeB0AKHJF_omrn1VzJBrRFcM,23
 monoco/features/skills/core.py,sha256=mpd0Cq-k2MvHRTPq9saFvZgYXUBGJ9pnK5lUmzUfZbY,3418
 monoco/features/spike/adapter.py,sha256=npJ4J775Df0DDi-LH-3u2jCuKjTIXyZUbLD0KNvHlcc,1062
 monoco/features/spike/commands.py,sha256=ctC2Kbe0fgpeDfw5106P0rsKEBDue0rFI4eMNRpXMDw,3880
-monoco/features/spike/core.py,sha256=vGMA3Tzuy0tB6r-FjnqcDalpiFWNw9CANSfQ5uV7Hg4,4589
+monoco/features/spike/core.py,sha256=oP1yAalOnoA5fHpf2o4gteKx73XGwZ6G0WrO86z2iWE,4174
 monoco/features/spike/resources/en/AGENTS.md,sha256=NG3CMnlDk_0J8hnRUcueAM9lgIQr_dZ42R_31-LC48E,306
 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=boGPgAfTHbEzdwomRh-qVEveWSgvYaPUdi_4YZVXGHI,1714
-monoco_toolkit-0.2.5.dist-info/METADATA,sha256=k2Bb7dwO7fDCUisJeMwmH53rJ7Gx4f44_8VHJF1O30A,3743
-monoco_toolkit-0.2.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-monoco_toolkit-0.2.5.dist-info/entry_points.txt,sha256=iYj7FWYBdtClU15-Du1skqD0s6SFSIhJvxJ29VWp8ng,43
-monoco_toolkit-0.2.5.dist-info/licenses/LICENSE,sha256=ACAGGjV6aod4eIlVUTx1q9PZbnZGN5bBwkSs9RHj83s,1071
-monoco_toolkit-0.2.5.dist-info/RECORD,,
+monoco/features/spike/resources/zh/SKILL.md,sha256=Q82e9lCQOAYIwBs5rGnvlVUDq7bp0pz8yvO10KTWFYQ,1710
+monoco_toolkit-0.2.7.dist-info/METADATA,sha256=25z_zO0Ycius1qg0GT66bgQRBEIUPJS4IBq6sHQ6aqU,4716
+monoco_toolkit-0.2.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+monoco_toolkit-0.2.7.dist-info/entry_points.txt,sha256=iYj7FWYBdtClU15-Du1skqD0s6SFSIhJvxJ29VWp8ng,43
+monoco_toolkit-0.2.7.dist-info/licenses/LICENSE,sha256=ACAGGjV6aod4eIlVUTx1q9PZbnZGN5bBwkSs9RHj83s,1071
+monoco_toolkit-0.2.7.dist-info/RECORD,,

monoco/features/agent/commands.py

@@ -1,166 +0,0 @@
-
-import typer
-from typing import Optional, Annotated
-from pathlib import Path
-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
-from monoco.core.config import get_config
-import asyncio
-import re
-import json as j
-
-app = typer.Typer()
-
-@app.command(name="run")
-def run_command(
-    prompt_or_task: str = typer.Argument(..., help="Prompt string OR execution task name (e.g. 'refine-issue')"),
-    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.
-    """
-    # 0. Setup
-    settings = get_config()
-    state_manager = AgentStateManager()
-    registry = ActionRegistry(Path(settings.paths.root))
-    
-    # 1. Check if it's a named task
-    action = registry.get(prompt_or_task)
-    
-    final_prompt = prompt_or_task
-    context_files = []
-    
-    # Determine Provider Priority: CLI > Action Def > Config > Default
-    prov_name = provider 
-    
-    if action:
-        # It IS an action
-        if not OutputManager.is_agent_mode():
-            print(f"Running action: {action.name}")
-        
-        # Simple template substitution
-        final_prompt = action.template
-        
-        if "{{file}}" in final_prompt:
-             if not target:
-                 print_error("This task requires a target file argument.")
-                 raise typer.Exit(1)
-             
-             target_path = Path(target).resolve()
-             if not target_path.exists():
-                 print_error(f"Target file not found: {target}")
-                 raise typer.Exit(1)
-                 
-             final_prompt = final_prompt.replace("{{file}}", target_path.read_text())
-             # Also add to context files? Ideally the prompt has it.
-             # Let's add it to context files list to be safe if prompt didn't embed it fully
-             context_files.append(target_path)
-             
-        if not prov_name:
-            prov_name = action.provider
-
-    # 2. Append Instruction if provided
-    if instruction:
-        final_prompt = f"{final_prompt}\n\n[USER INSTRUCTION]\n{instruction}"
-
-    # 2. Provider Resolution Fallback
-    prov_name = prov_name or settings.agent.framework or "gemini"
-
-    # 3. State Check
-    state = state_manager.load()
-    if not state or state.is_stale:
-        if not OutputManager.is_agent_mode():
-            print("Agent state stale or missing, refreshing...")
-        state = state_manager.refresh()
-    
-    if prov_name not in state.providers:
-         print_error(f"Provider '{prov_name}' unknown.")
-         raise typer.Exit(1)
-         
-    if not state.providers[prov_name].available:
-         print_error(f"Provider '{prov_name}' is not available. Run 'monoco doctor' to diagnose.")
-         raise typer.Exit(1)
-
-    # 4. Execute
-    try:
-        client = get_agent_client(prov_name)
-        result = asyncio.run(client.execute(final_prompt, context_files=context_files))
-        
-        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: AgentOutput = False,
-    context: Optional[str] = typer.Option(None, "--context", help="Context for filtering (JSON string)")
-):
-    """List available actions."""
-    settings = get_config()
-    registry = ActionRegistry(Path(settings.paths.root))
-    
-    action_context = None
-    if context:
-        try:
-            ctx_data = j.loads(context)
-            action_context = ActionContext(**ctx_data)
-        except Exception as e:
-            print_error(f"Invalid context JSON: {e}")
-
-    actions = registry.list_available(action_context)
-    # OutputManager handles list of Pydantic models automatically for both JSON and Table
-    print_output(actions, title="Available Actions")
-
-@app.command()
-def status(
-    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 OutputManager.is_agent_mode():
-        # Convert datetime to ISO string for JSON serialization
-        data = state.dict()
-        data["last_checked"] = data["last_checked"].isoformat()
-        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")
-        table.add_column("Path")
-        table.add_column("Error")
-        
-        for name, p_state in state.providers.items():
-            table.add_row(
-                name,
-                "✅" if p_state.available else "❌",
-                p_state.path or "-",
-                p_state.error or "-"
-            )
-        rprint(table)
-
-@app.command()
-def doctor(
-    force: bool = typer.Option(False, "--force", "-f", help="Force refresh of agent state")
-):
-    """
-    Diagnose Agent Environment and refresh state.
-    """
-    from monoco.features.agent.doctor import doctor as doc_impl
-    doc_impl(force)

monoco/features/agent/doctor.py

@@ -1,30 +0,0 @@
-import typer
-from monoco.core.output import print_output, print_error
-from monoco.core.agent.state import AgentStateManager
-
-app = typer.Typer()
-
-@app.command()
-def doctor(
-    force: bool = typer.Option(False, "--force", "-f", help="Force refresh of agent state")
-):
-    """
-    Diagnose Agent Environment and refresh state.
-    """
-    manager = AgentStateManager()
-    try:
-        if force:
-            print("Force refreshing agent state...")
-            state = manager.refresh()
-        else:
-            state = manager.get_or_refresh()
-            
-        print_output(state, title="Agent Diagnosis Report")
-        
-        # Simple summary
-        available = [k for k, v in state.providers.items() if v.available]
-        print(f"\n✅ Available Agents: {', '.join(available) if available else 'None'}")
-        
-    except Exception as e:
-        print_error(f"Doctor failed: {e}")
-        raise typer.Exit(1)

monoco/features/pty/core.py

@@ -1,185 +0,0 @@
-
-import asyncio
-import os
-import pty
-import select
-import signal
-import struct
-import fcntl
-import termios
-import logging
-from typing import Dict, Optional, Tuple, Any
-
-logger = logging.getLogger("monoco.pty")
-
-class PTYSession:
-    """
-    Manages a single PTY session connected to a subprocess (shell).
-    """
-    def __init__(self, session_id: str, cmd: list[str], env: Optional[Dict[str, str]] = None, cwd: Optional[str] = None):
-        self.session_id = session_id
-        self.cmd = cmd
-        self.env = env or os.environ.copy()
-        self.cwd = cwd or os.getcwd()
-        
-        self.fd: Optional[int] = None
-        self.pid: Optional[int] = None
-        self.proc = None # subprocess.Popen object
-        self.running = False
-        self.loop = asyncio.get_running_loop()
-
-    def start(self, cols: int = 80, rows: int = 24):
-        """
-        Spawn a subprocess connected to a new PTY using subprocess.Popen.
-        This provides better safety in threaded/asyncio environments than pty.fork().
-        """
-        import subprocess
-
-        # 1. Open PTY pair
-        master_fd, slave_fd = pty.openpty()
-        
-        # 2. Set initial size
-        self._set_winsize(master_fd, rows, cols)
-
-        try:
-            # 3. Spawn process
-            # start_new_session=True executes setsid()
-            self.proc = subprocess.Popen(
-                self.cmd,
-                stdin=slave_fd,
-                stdout=slave_fd,
-                stderr=slave_fd,
-                cwd=self.cwd,
-                env=self.env,
-                start_new_session=True,
-                close_fds=True # Important to close other FDs in child
-            )
-            
-            self.pid = self.proc.pid
-            self.fd = master_fd
-            self.running = True
-            
-            # 4. Close slave fd in parent (child has it open now)
-            os.close(slave_fd)
-            
-            logger.info(f"Started session {self.session_id} (PID: {self.pid})")
-            
-        except Exception as e:
-            logger.error(f"Failed to spawn process: {e}")
-            # Ensure we clean up fds if spawn fails
-            try:
-                os.close(master_fd)
-            except: pass
-            try:
-                os.close(slave_fd)
-            except: pass
-            raise e
-
-
-    def resize(self, cols: int, rows: int):
-        """
-        Resize the PTY.
-        """
-        if self.fd and self.running:
-            self._set_winsize(self.fd, rows, cols)
-
-    def write(self, data: bytes):
-        """
-        Write input data (from websocket) to the PTY master fd.
-        """
-        if self.fd and self.running:
-            os.write(self.fd, data)
-
-    async def read(self) -> bytes:
-        """
-        Read output data from PTY master fd (to forward to websocket).
-        """
-        if not self.fd or not self.running:
-            return b""
-            
-        try:
-            # Run in executor to avoid blocking the event loop
-            # pty read is blocking
-            return await self.loop.run_in_executor(None, self._read_blocking)
-        except OSError:
-            return b""
-
-    def _read_blocking(self) -> bytes:
-        try:
-            return os.read(self.fd, 1024)
-        except OSError:
-            return b""
-
-    def terminate(self):
-        """
-        Terminate the process and close the PTY.
-        """
-        self.running = False
-        
-        # Use Popen object if available
-        if self.proc:
-            try:
-                self.proc.terminate()
-                try:
-                    self.proc.wait(timeout=1.0)
-                except:
-                    # Force kill if not terminated
-                    self.proc.kill()
-                    self.proc.wait()
-            except Exception as e:
-                logger.error(f"Error terminating process: {e}")
-            self.proc = None
-            self.pid = None
-        elif self.pid:
-            # Fallback for legacy or if Popen obj lost
-            try:
-                os.kill(self.pid, signal.SIGTERM)
-                os.waitpid(self.pid, 0) # Reap zombie
-            except OSError:
-                pass
-            self.pid = None
-            
-        if self.fd:
-            try:
-                os.close(self.fd)
-            except OSError:
-                pass
-            self.fd = None
-        logger.info(f"Terminated session {self.session_id}")
-
-    def _set_winsize(self, fd: int, row: int, col: int, xpix: int = 0, ypix: int = 0):
-        winsize = struct.pack("HHHH", row, col, xpix, ypix)
-        fcntl.ioctl(fd, termios.TIOCSWINSZ, winsize)
-
-
-class PTYManager:
-    """
-    Singleton to manage multiple PTY sessions.
-    """
-    def __init__(self):
-        self.sessions: Dict[str, PTYSession] = {}
-
-    def create_session(self, session_id: str, cwd: str, cmd: list[str] = ["/bin/zsh"], env: Dict = None) -> PTYSession:
-        if session_id in self.sessions:
-            # In a real app, we might want to attach to existing?
-            # For now, kill and recreate (or error)
-            self.close_session(session_id)
-            
-        session = PTYSession(session_id, cmd, env, cwd)
-        self.sessions[session_id] = session
-        return session
-
-    def get_session(self, session_id: str) -> Optional[PTYSession]:
-        return self.sessions.get(session_id)
-
-    def close_session(self, session_id: str):
-        if session_id in self.sessions:
-            self.sessions[session_id].terminate()
-            del self.sessions[session_id]
-
-    def close_all_sessions(self):
-        """
-        Terminate all active PTY sessions.
-        """
-        for session_id in list(self.sessions.keys()):
-            self.close_session(session_id)

monoco/features/pty/router.py

@@ -1,138 +0,0 @@
-
-from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Query
-from pydantic import BaseModel
-from typing import Optional, Dict
-import json
-import asyncio
-import logging
-import os
-from pathlib import Path
-from monoco.features.pty.core import PTYManager
-from monoco.core.config import get_config
-
-# We will use dependency injection or a global singleton for now
-# Ideally attached to app state
-pty_manager = PTYManager()
-
-router = APIRouter(prefix="/api/v1/pty", tags=["pty"])
-
-logger = logging.getLogger("monoco.pty")
-
-@router.websocket("/ws/{session_id}")
-async def websocket_pty_endpoint(
-    websocket: WebSocket, 
-    session_id: str,
-    cwd: Optional[str] = Query(None),
-    cols: int = Query(80), 
-    rows: int = Query(24),
-    env: Optional[str] = Query(None) # JSON-encoded env vars
-):
-    await websocket.accept()
-    
-    # Determine working directory
-    # 1. Provide explicit CWD in query
-    # 2. Or fallback to ProjectRoot from env (if integrated)
-    # 3. Or fallback to process CWD
-    
-    # Since monoco pty runs as a separate service, we expect CWD to be passed
-    # or we default to where monoco pty was started
-    working_dir = cwd if cwd else os.getcwd()
-    
-    # Prepare environment
-    env_vars = os.environ.copy()
-    env_vars["TERM"] = "xterm-256color"
-    env_vars["COLORTERM"] = "truecolor"
-    if "SHELL" not in env_vars:
-        env_vars["SHELL"] = "/bin/zsh"
-    if "HOME" not in env_vars:
-        import pathlib
-        env_vars["HOME"] = str(pathlib.Path.home())
-
-    # Filter out Trae/Gemini specific variables to avoid shell integration conflicts
-    # This prevents the shell from trying to write to IDE-specific logs which causes EPERM
-    keys_to_remove = [k for k in env_vars.keys() if k.startswith("TRAE_") or k.startswith("GEMINI_") or k == "AI_AGENT"]
-    for k in keys_to_remove:
-        del env_vars[k]
-
-    if env:
-        try:
-            custom_env = json.loads(env)
-            env_vars.update(custom_env)
-        except:
-            logger.warning("Failed to parse custom env vars")
-
-    # Start Session
-    try:
-        session = pty_manager.create_session(
-            session_id=session_id, 
-            cwd=working_dir,
-            cmd=["/bin/zsh", "-l"], # Use login shell to ensure full user environment
-            env=env_vars
-        )
-        session.start(cols, rows)
-    except Exception as e:
-        logger.error(f"Failed to start session: {e}")
-        await websocket.close(code=1011)
-        return
-
-    # Pipe Loop
-    reader_task = None
-    try:
-        # Task to read from PTY and send to WebSocket
-        async def pty_reader():
-            while session.running:
-                data = await session.read()
-                if not data:
-                    break
-                # xterm.js expects string or binary. We send string/bytes.
-                # Usually text is fine, but binary is safer for control codes.
-                await websocket.send_bytes(data)
-            
-            # If PTY exits, close WS
-            await websocket.close()
-
-        reader_task = asyncio.create_task(pty_reader())
-
-        # Main loop: Read from WebSocket and write to PTY
-        try:
-            while True:
-                # Receive message from Client (xterm.js)
-                # Message can be simple input string, or a JSON command (resize)
-                message = await websocket.receive()
-                
-                if message["type"] == "websocket.disconnect":
-                    raise WebSocketDisconnect(code=message.get("code", 1000))
-                
-                if "text" in message:
-                    payload = message["text"]
-                    
-                    # Check if it's a control message (Hack: usually client sends raw input)
-                    # We can enforce a protocol: binary for Input, text JSON for Control.
-                    try:
-                        # Try parsing as JSON control message
-                        cmd = json.loads(payload)
-                        if cmd.get("type") == "resize":
-                            session.resize(cmd["cols"], cmd["rows"])
-                            continue
-                    except:
-                        pass # Not JSON, treat as raw input
-                    
-                    session.write(payload.encode())
-                    
-                elif "bytes" in message:
-                    session.write(message["bytes"])
-        except RuntimeError:
-            # Handle "Cannot call 'receive' once a disconnect message has been received"
-            # This happens if Starlette/FastAPI already processed the disconnect internally
-            # but we called receive() again.
-            logger.info(f"Runtime disconnect for session {session_id}")
-
-    except WebSocketDisconnect:
-        logger.info(f"Client disconnected for session {session_id}")
-    except Exception as e:
-        logger.error(f"WebSocket error: {e}")
-    finally:
-        # Cleanup
-        pty_manager.close_session(session_id)
-        if reader_task and not reader_task.done():
-            reader_task.cancel()