zwarm 0.1.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

zwarm/adapters/test_codex_mcp.py

@@ -1,10 +1,9 @@
 """Tests for Codex MCP adapter."""
 
-import asyncio
 import subprocess
 import tempfile
 from pathlib import Path
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import MagicMock, patch
 
 import pytest
 
@@ -16,8 +15,8 @@ class TestMCPClient:
     """Tests for the MCP client."""
 
     def test_next_id_increments(self):
-        proc = MagicMock()
-        client = MCPClient(proc)
+        """Test that request IDs increment properly."""
+        client = MCPClient()
         assert client._next_id() == 1
         assert client._next_id() == 2
         assert client._next_id() == 3
@@ -34,14 +33,14 @@ class TestCodexMCPAdapter:
     async def test_start_session_creates_session(self, adapter):
         """Test that start_session creates a proper session object."""
         with tempfile.TemporaryDirectory() as tmpdir:
-            # Mock the MCP client
-            mock_client = AsyncMock()
-            mock_client.call_tool = AsyncMock(return_value={
-                "conversationId": "conv-123",
-                "content": [{"text": "Hello! I'll help you with that."}],
-            })
-
-            with patch.object(adapter, "_ensure_server", return_value=mock_client):
+            # Mock the _call_codex method (now synchronous)
+            with patch.object(adapter, "_call_codex", return_value={
+                "conversation_id": "conv-123",
+                "response": "Hello! I'll help you with that.",
+                "raw_messages": [],
+                "usage": {},
+                "total_usage": {},
+            }):
                 session = await adapter.start_session(
                     task="Say hello",
                     working_dir=Path(tmpdir),
@@ -60,26 +59,27 @@ class TestCodexMCPAdapter:
     async def test_send_message_continues_conversation(self, adapter):
         """Test that send_message continues an existing conversation."""
         with tempfile.TemporaryDirectory() as tmpdir:
-            mock_client = AsyncMock()
-            mock_client.call_tool = AsyncMock(side_effect=[
-                # First call: start session
-                {
-                    "conversationId": "conv-123",
-                    "content": [{"text": "Initial response"}],
-                },
-                # Second call: reply
-                {
-                    "content": [{"text": "Follow-up response"}],
-                },
-            ])
-
-            with patch.object(adapter, "_ensure_server", return_value=mock_client):
+            # Mock _call_codex for start_session
+            with patch.object(adapter, "_call_codex", return_value={
+                "conversation_id": "conv-123",
+                "response": "Initial response",
+                "raw_messages": [],
+                "usage": {},
+                "total_usage": {},
+            }):
                 session = await adapter.start_session(
                     task="Start task",
                     working_dir=Path(tmpdir),
                     mode="sync",
                 )
 
+            # Mock _call_codex_reply for send_message
+            with patch.object(adapter, "_call_codex_reply", return_value={
+                "response": "Follow-up response",
+                "raw_messages": [],
+                "usage": {},
+                "total_usage": {},
+            }):
                 response = await adapter.send_message(session, "Continue please")
 
                 assert response == "Follow-up response"

zwarm/cli/main.py

@@ -12,6 +12,7 @@ Commands:
 from __future__ import annotations
 
 import asyncio
+import os
 import sys
 from enum import Enum
 from pathlib import Path
@@ -65,8 +66,8 @@ app = typer.Typer(
     delegation, conversation, and trajectory alignment (watchers).
 
 [bold]QUICK START[/]
-    [dim]# Test an executor directly[/]
-    $ zwarm exec --task "What is 2+2?"
+    [dim]# Initialize zwarm in your project[/]
+    $ zwarm init
 
     [dim]# Run the orchestrator[/]
     $ zwarm orchestrate --task "Build a hello world function"
@@ -75,6 +76,8 @@ app = typer.Typer(
     $ zwarm status
 
 [bold]COMMANDS[/]
+    [cyan]init[/]         Initialize zwarm (create config.toml, .zwarm/)
+    [cyan]reset[/]        Reset state and optionally config files
     [cyan]orchestrate[/]  Start orchestrator to delegate tasks to executors
     [cyan]exec[/]         Run a single executor directly (for testing)
     [cyan]status[/]       Show current state (sessions, tasks, events)
@@ -264,7 +267,7 @@ def exec(
     console.print(f"  Task: {task}")
 
     if adapter == AdapterType.codex_mcp:
-        executor = CodexMCPAdapter()
+        executor = CodexMCPAdapter(model=model)
     elif adapter == AdapterType.claude_code:
         executor = ClaudeCodeAdapter(model=model)
     else:
@@ -514,6 +517,464 @@ def configs_show(
         raise typer.Exit(1)
 
 
+@app.command()
+def init(
+    working_dir: Annotated[Path, typer.Option("--working-dir", "-w", help="Working directory")] = Path("."),
+    non_interactive: Annotated[bool, typer.Option("--yes", "-y", help="Accept defaults, no prompts")] = False,
+    with_project: Annotated[bool, typer.Option("--with-project", help="Create zwarm.yaml project config")] = False,
+):
+    """
+    Initialize zwarm in the current directory.
+
+    Creates configuration files and the .zwarm state directory.
+    Run this once per project to set up zwarm.
+
+    [bold]Creates:[/]
+        [cyan]config.toml[/]   Runtime settings (weave, adapter, watchers)
+        [cyan].zwarm/[/]       State directory for sessions and events
+        [cyan]zwarm.yaml[/]    Project config (optional, with --with-project)
+
+    [bold]Examples:[/]
+        [dim]# Interactive setup[/]
+        $ zwarm init
+
+        [dim]# Quick setup with defaults[/]
+        $ zwarm init --yes
+
+        [dim]# Full setup with project config[/]
+        $ zwarm init --with-project
+    """
+    console.print("\n[bold cyan]zwarm init[/] - Initialize zwarm configuration\n")
+
+    config_toml_path = working_dir / "config.toml"
+    zwarm_yaml_path = working_dir / "zwarm.yaml"
+    state_dir = working_dir / ".zwarm"
+
+    # Check for existing files
+    if config_toml_path.exists():
+        console.print(f"[yellow]Warning:[/] config.toml already exists")
+        if not non_interactive:
+            overwrite = typer.confirm("Overwrite?", default=False)
+            if not overwrite:
+                console.print("[dim]Skipping config.toml[/]")
+                config_toml_path = None
+        else:
+            config_toml_path = None
+
+    # Gather settings
+    weave_project = ""
+    adapter = "codex_mcp"
+    watchers_enabled = ["progress", "budget", "delegation"]
+    create_project_config = with_project
+    project_description = ""
+    project_context = ""
+
+    if not non_interactive:
+        console.print("[bold]Configuration[/]\n")
+
+        # Weave project
+        weave_project = typer.prompt(
+            "  Weave project (entity/project, blank to skip)",
+            default="",
+            show_default=False,
+        )
+
+        # Adapter
+        adapter = typer.prompt(
+            "  Default adapter",
+            default="codex_mcp",
+            type=str,
+        )
+
+        # Watchers
+        console.print("\n  [bold]Watchers[/] (trajectory aligners)")
+        available_watchers = ["progress", "budget", "delegation", "scope", "pattern", "quality"]
+        watchers_enabled = []
+        for w in available_watchers:
+            default = w in ["progress", "budget", "delegation"]
+            if typer.confirm(f"    Enable {w}?", default=default):
+                watchers_enabled.append(w)
+
+        # Project config
+        console.print()
+        create_project_config = typer.confirm(
+            "  Create zwarm.yaml project config?",
+            default=with_project,
+        )
+
+        if create_project_config:
+            project_description = typer.prompt(
+                "    Project description",
+                default="",
+                show_default=False,
+            )
+            console.print("    [dim]Project context (optional, press Enter twice to finish):[/]")
+            context_lines = []
+            while True:
+                line = typer.prompt("    ", default="", show_default=False)
+                if not line:
+                    break
+                context_lines.append(line)
+            project_context = "\n".join(context_lines)
+
+    # Create .zwarm directory
+    console.print("\n[bold]Creating files...[/]\n")
+
+    state_dir.mkdir(parents=True, exist_ok=True)
+    (state_dir / "sessions").mkdir(exist_ok=True)
+    (state_dir / "orchestrator").mkdir(exist_ok=True)
+    console.print(f"  [green]✓[/] Created .zwarm/")
+
+    # Create config.toml
+    if config_toml_path:
+        toml_content = _generate_config_toml(
+            weave_project=weave_project,
+            adapter=adapter,
+            watchers=watchers_enabled,
+        )
+        config_toml_path.write_text(toml_content)
+        console.print(f"  [green]✓[/] Created config.toml")
+
+    # Create zwarm.yaml
+    if create_project_config:
+        if zwarm_yaml_path.exists() and not non_interactive:
+            overwrite = typer.confirm("  zwarm.yaml exists. Overwrite?", default=False)
+            if not overwrite:
+                create_project_config = False
+
+        if create_project_config:
+            yaml_content = _generate_zwarm_yaml(
+                description=project_description,
+                context=project_context,
+                watchers=watchers_enabled,
+            )
+            zwarm_yaml_path.write_text(yaml_content)
+            console.print(f"  [green]✓[/] Created zwarm.yaml")
+
+    # Summary
+    console.print("\n[bold green]Done![/] zwarm is ready.\n")
+    console.print("[bold]Next steps:[/]")
+    console.print("  [dim]# Run the orchestrator[/]")
+    console.print("  $ zwarm orchestrate --task \"Your task here\"\n")
+    console.print("  [dim]# Or test an executor directly[/]")
+    console.print("  $ zwarm exec --task \"What is 2+2?\"\n")
+
+
+def _generate_config_toml(
+    weave_project: str = "",
+    adapter: str = "codex_mcp",
+    watchers: list[str] | None = None,
+) -> str:
+    """Generate config.toml content."""
+    watchers = watchers or []
+
+    lines = [
+        "# zwarm configuration",
+        "# Generated by 'zwarm init'",
+        "",
+        "[weave]",
+    ]
+
+    if weave_project:
+        lines.append(f'project = "{weave_project}"')
+    else:
+        lines.append("# project = \"your-entity/your-project\"  # Uncomment to enable Weave tracing")
+
+    lines.extend([
+        "",
+        "[orchestrator]",
+        "max_steps = 50",
+        "",
+        "[executor]",
+        f'adapter = "{adapter}"',
+        "# model = \"\"  # Optional model override",
+        "",
+        "[watchers]",
+        f"enabled = {watchers}",
+        "",
+        "# Watcher-specific configuration",
+        "# [watchers.budget]",
+        "# max_steps = 50",
+        "# warn_at_percent = 80",
+        "",
+        "# [watchers.pattern]",
+        "# patterns = [\"DROP TABLE\", \"rm -rf\"]",
+        "",
+    ])
+
+    return "\n".join(lines)
+
+
+def _generate_zwarm_yaml(
+    description: str = "",
+    context: str = "",
+    watchers: list[str] | None = None,
+) -> str:
+    """Generate zwarm.yaml project config."""
+    watchers = watchers or []
+
+    lines = [
+        "# zwarm project configuration",
+        "# Customize the orchestrator for this specific project",
+        "",
+        f'description: "{description}"' if description else 'description: ""',
+        "",
+        "# Project-specific context injected into the orchestrator",
+        "# This helps the orchestrator understand your codebase",
+        "context: |",
+    ]
+
+    if context:
+        for line in context.split("\n"):
+            lines.append(f"  {line}")
+    else:
+        lines.extend([
+            "  # Describe your project here. For example:",
+            "  # - Tech stack (FastAPI, React, PostgreSQL)",
+            "  # - Key directories (src/api/, src/components/)",
+            "  # - Coding conventions to follow",
+        ])
+
+    lines.extend([
+        "",
+        "# Project-specific constraints",
+        "# The orchestrator will be reminded to follow these",
+        "constraints:",
+        "  # - \"Never modify migration files directly\"",
+        "  # - \"All new endpoints need tests\"",
+        "  # - \"Use existing patterns from src/api/\"",
+        "",
+        "# Default watchers for this project",
+        "watchers:",
+    ])
+
+    for w in watchers:
+        lines.append(f"  - {w}")
+
+    if not watchers:
+        lines.append("  # - progress")
+        lines.append("  # - budget")
+
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+@app.command()
+def reset(
+    working_dir: Annotated[Path, typer.Option("--working-dir", "-w", help="Working directory")] = Path("."),
+    state: Annotated[bool, typer.Option("--state", "-s", help="Reset .zwarm/ state directory")] = True,
+    config: Annotated[bool, typer.Option("--config", "-c", help="Also delete config.toml")] = False,
+    project: Annotated[bool, typer.Option("--project", "-p", help="Also delete zwarm.yaml")] = False,
+    all_files: Annotated[bool, typer.Option("--all", "-a", help="Delete everything (state + config + project)")] = False,
+    force: Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation")] = False,
+):
+    """
+    Reset zwarm state and optionally configuration files.
+
+    By default, only clears the .zwarm/ state directory (sessions, events, orchestrator history).
+    Use flags to also remove configuration files.
+
+    [bold]Examples:[/]
+        [dim]# Reset state only (default)[/]
+        $ zwarm reset
+
+        [dim]# Reset everything, no confirmation[/]
+        $ zwarm reset --all --yes
+
+        [dim]# Reset state and config.toml[/]
+        $ zwarm reset --config
+    """
+    import shutil
+
+    console.print("\n[bold cyan]zwarm reset[/] - Reset zwarm state\n")
+
+    state_dir = working_dir / ".zwarm"
+    config_toml_path = working_dir / "config.toml"
+    zwarm_yaml_path = working_dir / "zwarm.yaml"
+
+    # Expand --all flag
+    if all_files:
+        state = True
+        config = True
+        project = True
+
+    # Collect what will be deleted
+    to_delete = []
+    if state and state_dir.exists():
+        to_delete.append((".zwarm/", state_dir))
+    if config and config_toml_path.exists():
+        to_delete.append(("config.toml", config_toml_path))
+    if project and zwarm_yaml_path.exists():
+        to_delete.append(("zwarm.yaml", zwarm_yaml_path))
+
+    if not to_delete:
+        console.print("[yellow]Nothing to reset.[/] No matching files found.")
+        raise typer.Exit(0)
+
+    # Show what will be deleted
+    console.print("[bold]Will delete:[/]")
+    for name, path in to_delete:
+        if path.is_dir():
+            # Count contents
+            files = list(path.rglob("*"))
+            file_count = len([f for f in files if f.is_file()])
+            console.print(f"  [red]✗[/] {name} ({file_count} files)")
+        else:
+            console.print(f"  [red]✗[/] {name}")
+
+    # Confirm
+    if not force:
+        console.print()
+        confirm = typer.confirm("Proceed with reset?", default=False)
+        if not confirm:
+            console.print("[dim]Aborted.[/]")
+            raise typer.Exit(0)
+
+    # Delete
+    console.print("\n[bold]Deleting...[/]")
+    for name, path in to_delete:
+        try:
+            if path.is_dir():
+                shutil.rmtree(path)
+            else:
+                path.unlink()
+            console.print(f"  [green]✓[/] Deleted {name}")
+        except Exception as e:
+            console.print(f"  [red]✗[/] Failed to delete {name}: {e}")
+
+    console.print("\n[bold green]Reset complete.[/]")
+    console.print("\n[dim]Run 'zwarm init' to set up again.[/]\n")
+
+
+@app.command()
+def clean(
+    force: Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run", "-n", help="Show what would be killed without killing")] = False,
+):
+    """
+    Clean up orphaned processes from zwarm sessions.
+
+    Finds and kills:
+    - Orphaned codex mcp-server processes
+    - Orphaned codex exec processes
+    - Orphaned claude CLI processes
+
+    [bold]Examples:[/]
+        [dim]# See what would be cleaned[/]
+        $ zwarm clean --dry-run
+
+        [dim]# Clean without confirmation[/]
+        $ zwarm clean --yes
+    """
+    import subprocess
+    import signal
+
+    console.print("\n[bold cyan]zwarm clean[/] - Clean up orphaned processes\n")
+
+    # Patterns to search for
+    patterns = [
+        ("codex mcp-server", "Codex MCP server"),
+        ("codex exec", "Codex exec"),
+        ("claude.*--permission-mode", "Claude CLI"),
+    ]
+
+    found_processes = []
+
+    for pattern, description in patterns:
+        try:
+            # Use pgrep to find matching processes
+            result = subprocess.run(
+                ["pgrep", "-f", pattern],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                pids = result.stdout.strip().split("\n")
+                for pid in pids:
+                    pid = pid.strip()
+                    if pid and pid.isdigit():
+                        # Get process info
+                        try:
+                            ps_result = subprocess.run(
+                                ["ps", "-p", pid, "-o", "pid,ppid,etime,command"],
+                                capture_output=True,
+                                text=True,
+                            )
+                            if ps_result.returncode == 0:
+                                lines = ps_result.stdout.strip().split("\n")
+                                if len(lines) > 1:
+                                    # Skip header, get process line
+                                    proc_info = lines[1].strip()
+                                    found_processes.append((int(pid), description, proc_info))
+                        except Exception:
+                            found_processes.append((int(pid), description, "(unknown)"))
+        except FileNotFoundError:
+            # pgrep not available, try ps with grep
+            try:
+                result = subprocess.run(
+                    f"ps aux | grep '{pattern}' | grep -v grep",
+                    shell=True,
+                    capture_output=True,
+                    text=True,
+                )
+                if result.returncode == 0 and result.stdout.strip():
+                    for line in result.stdout.strip().split("\n"):
+                        parts = line.split()
+                        if len(parts) >= 2:
+                            pid = parts[1]
+                            if pid.isdigit():
+                                found_processes.append((int(pid), description, line[:80]))
+            except Exception:
+                pass
+        except Exception as e:
+            console.print(f"[yellow]Warning:[/] Error searching for {description}: {e}")
+
+    if not found_processes:
+        console.print("[green]No orphaned processes found.[/] Nothing to clean.\n")
+        raise typer.Exit(0)
+
+    # Show what was found
+    console.print(f"[bold]Found {len(found_processes)} process(es):[/]\n")
+    for pid, description, info in found_processes:
+        console.print(f"  [yellow]PID {pid}[/] - {description}")
+        console.print(f"    [dim]{info[:100]}{'...' if len(info) > 100 else ''}[/]")
+
+    if dry_run:
+        console.print("\n[dim]Dry run - no processes killed.[/]\n")
+        raise typer.Exit(0)
+
+    # Confirm
+    if not force:
+        console.print()
+        confirm = typer.confirm(f"Kill {len(found_processes)} process(es)?", default=False)
+        if not confirm:
+            console.print("[dim]Aborted.[/]")
+            raise typer.Exit(0)
+
+    # Kill processes
+    console.print("\n[bold]Cleaning up...[/]")
+    killed = 0
+    failed = 0
+
+    for pid, description, _ in found_processes:
+        try:
+            # First try SIGTERM
+            os.kill(pid, signal.SIGTERM)
+            console.print(f"  [green]✓[/] Killed PID {pid} ({description})")
+            killed += 1
+        except ProcessLookupError:
+            console.print(f"  [dim]○[/] PID {pid} already gone")
+        except PermissionError:
+            console.print(f"  [red]✗[/] PID {pid} - permission denied (try sudo)")
+            failed += 1
+        except Exception as e:
+            console.print(f"  [red]✗[/] PID {pid} - {e}")
+            failed += 1
+
+    console.print(f"\n[bold green]Cleanup complete.[/] Killed {killed}, failed {failed}.\n")
+
+
 @app.callback(invoke_without_command=True)
 def main_callback(
     ctx: typer.Context,