zwarm 2.3__py3-none-any.whl → 3.0__py3-none-any.whl

zwarm/cli/main.py

@@ -79,6 +79,7 @@ app = typer.Typer(
     [cyan]init[/]         Initialize zwarm (creates .zwarm/ with config)
     [cyan]reset[/]        Reset state and optionally config files
     [cyan]orchestrate[/]  Start orchestrator to delegate tasks to executors
+    [cyan]pilot[/]        Conversational orchestrator REPL (interactive)
     [cyan]exec[/]         Run a single executor directly (for testing)
     [cyan]status[/]       Show current state (sessions, tasks, events)
     [cyan]history[/]      Show event history log
@@ -274,6 +275,112 @@ def orchestrate(
         sys.exit(1)
 
 
+class PilotLM(str, Enum):
+    """LM options for pilot mode."""
+    gpt5_mini = "gpt5-mini"      # GPT5MiniTester - fast, cheap, good for testing
+    gpt5 = "gpt5"                # GPT5Large - standard
+    gpt5_verbose = "gpt5-verbose"  # GPT5LargeVerbose - with extended thinking
+
+
+@app.command()
+def pilot(
+    task: Annotated[Optional[str], typer.Option("--task", "-t", help="Initial task (optional)")] = None,
+    task_file: Annotated[Optional[Path], typer.Option("--task-file", "-f", help="Read task from file")] = None,
+    config: Annotated[Optional[Path], typer.Option("--config", "-c", help="Path to config YAML")] = None,
+    overrides: Annotated[Optional[list[str]], typer.Option("--set", help="Override config (key=value)")] = None,
+    working_dir: Annotated[Path, typer.Option("--working-dir", "-w", help="Working directory")] = Path("."),
+    instance: Annotated[Optional[str], typer.Option("--instance", "-i", help="Instance ID (for isolation)")] = None,
+    instance_name: Annotated[Optional[str], typer.Option("--name", "-n", help="Human-readable instance name")] = None,
+    model: Annotated[PilotLM, typer.Option("--model", "-m", help="LM to use")] = PilotLM.gpt5_verbose,
+):
+    """
+    Interactive conversational orchestrator REPL.
+
+    Like 'orchestrate' but conversational: give instructions, watch the
+    orchestrator work, course-correct in real-time, time-travel to checkpoints.
+
+    [bold]Features:[/]
+        - Streaming display of orchestrator thinking and tool calls
+        - Turn-by-turn execution with checkpoints
+        - Time travel (:goto T1) to return to previous states
+        - Session visibility (:sessions) and state inspection (:state)
+
+    [bold]Commands:[/]
+        :help              Show help
+        :history [N|all]   Show turn checkpoints
+        :goto <turn|root>  Time travel (e.g., :goto T1)
+        :state             Show orchestrator state
+        :sessions          Show active executor sessions
+        :reasoning on|off  Toggle reasoning display
+        :quit              Exit
+
+    [bold]LM Options:[/]
+        gpt5-mini     GPT5MiniTester - fast/cheap, good for testing
+        gpt5          GPT5Large - standard model
+        gpt5-verbose  GPT5LargeVerbose - with extended thinking (default)
+
+    [bold]Examples:[/]
+        [dim]# Start fresh, give instructions interactively[/]
+        $ zwarm pilot
+
+        [dim]# Start with an initial task[/]
+        $ zwarm pilot --task "Build user authentication"
+
+        [dim]# Use faster model for testing[/]
+        $ zwarm pilot --model gpt5-mini
+
+        [dim]# Named instance[/]
+        $ zwarm pilot --name my-feature
+    """
+    from zwarm.cli.pilot import run_pilot, build_pilot_orchestrator
+
+    # Resolve task (optional for pilot)
+    resolved_task = _resolve_task(task, task_file)
+
+    console.print(f"[bold]Starting pilot session...[/]")
+    console.print(f"  Working dir: {working_dir.absolute()}")
+    console.print(f"  Model: {model.value}")
+    if resolved_task:
+        console.print(f"  Initial task: {resolved_task[:60]}...")
+    if instance:
+        console.print(f"  Instance: {instance}" + (f" ({instance_name})" if instance_name else ""))
+    console.print()
+
+    orchestrator = None
+    try:
+        orchestrator = build_pilot_orchestrator(
+            config_path=config,
+            working_dir=working_dir.absolute(),
+            overrides=list(overrides or []),
+            instance_id=instance,
+            instance_name=instance_name,
+            lm_choice=model.value,
+        )
+
+        # Show instance ID if auto-generated
+        if orchestrator.instance_id and not instance:
+            console.print(f"  [dim]Instance: {orchestrator.instance_id[:8]}[/]")
+
+        # Run the pilot REPL
+        run_pilot(orchestrator, initial_task=resolved_task)
+
+        # Save state on exit
+        orchestrator.save_state()
+        console.print("\n[dim]State saved.[/]")
+
+    except KeyboardInterrupt:
+        console.print("\n\n[yellow]Interrupted.[/]")
+        if orchestrator:
+            orchestrator.save_state()
+            console.print("[dim]State saved.[/]")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"\n[red]Error:[/] {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
 @app.command()
 def exec(
     task: Annotated[str, typer.Option("--task", "-t", help="Task to execute")],
@@ -1151,6 +1258,7 @@ def interactive(
         [cyan]ls[/] / [cyan]list[/]               Dashboard of all sessions
         [cyan]?[/] ID                    Quick peek (status + latest message)
         [cyan]show[/] ID                  Full session details & history
+        [cyan]traj[/] ID                  Show trajectory (all steps taken)
         [cyan]c[/] / [cyan]continue[/] ID "msg"   Continue a sync conversation
         [cyan]kill[/] ID                  Stop a session (keeps in history)
         [cyan]rm[/] ID                    Delete session entirely
@@ -1230,11 +1338,14 @@ def interactive(
         help_table.add_row("  --async", "Background mode (don't wait)")
         help_table.add_row("", "")
         help_table.add_row("ls / list", "Dashboard of all sessions")
-        help_table.add_row("? / show ID", "Show session details & messages")
+        help_table.add_row("? ID / peek ID", "Quick peek (status + latest message)")
+        help_table.add_row("show ID", "Full session details & messages")
+        help_table.add_row("traj ID [--full]", "Show trajectory (all steps taken)")
         help_table.add_row('c ID "msg"', "Continue conversation (wait for response)")
         help_table.add_row('ca ID "msg"', "Continue async (fire-and-forget)")
         help_table.add_row("check ID", "Check session status")
         help_table.add_row("kill ID", "Stop a running session")
+        help_table.add_row("rm ID", "Delete session entirely")
         help_table.add_row("killall", "Stop all running sessions")
         help_table.add_row("clean", "Remove old completed sessions")
         help_table.add_row("q / quit", "Exit")
@@ -1619,6 +1730,93 @@ def interactive(
         if session.error:
             console.print(f"[red]Error:[/] {session.error}")
 
+    def do_trajectory(session_id: str, full: bool = False):
+        """Show the full trajectory of a session - all steps in order."""
+        from zwarm.sessions import CodexSessionManager
+
+        manager = CodexSessionManager(default_dir / ".zwarm")
+        session = manager.get_session(session_id)
+
+        if not session:
+            console.print(f"  [red]Session not found:[/] {session_id}")
+            return
+
+        trajectory = manager.get_trajectory(session_id, full=full)
+
+        if not trajectory:
+            console.print("[dim]No trajectory data available.[/]")
+            return
+
+        mode = "[bold](full)[/] " if full else ""
+        console.print(f"\n[bold cyan]Trajectory: {session.short_id}[/] {mode}({len(trajectory)} steps)")
+        console.print(f"[dim]Task: {session.task[:60]}{'...' if len(session.task) > 60 else ''}[/]")
+        console.print()
+
+        # Display each step
+        for step in trajectory:
+            turn = step.get("turn", 1)
+            step_num = step.get("step", 0)
+            step_type = step.get("type", "unknown")
+
+            prefix = f"[dim]T{turn}.{step_num:02d}[/]"
+
+            if step_type == "reasoning":
+                if full and step.get("full_text"):
+                    console.print(f"{prefix} [yellow]thinking:[/]")
+                    console.print(f"       {step['full_text']}")
+                else:
+                    summary = step.get("summary", "")
+                    console.print(f"{prefix} [yellow]thinking:[/] {summary}")
+
+            elif step_type == "command":
+                cmd = step.get("command", "")
+                output = step.get("output", "")
+                exit_code = step.get("exit_code", "?")
+                # Show command
+                console.print(f"{prefix} [cyan]$ {cmd}[/]")
+                if output:
+                    if full:
+                        # Show all output
+                        for line in output.split("\n"):
+                            console.print(f"       [dim]{line}[/]")
+                    else:
+                        # Indent output, max 5 lines
+                        for line in output.split("\n")[:5]:
+                            console.print(f"       [dim]{line}[/]")
+                        if output.count("\n") > 5:
+                            console.print(f"       [dim]... ({output.count(chr(10))} lines)[/]")
+                if exit_code != 0 and exit_code is not None:
+                    console.print(f"       [red]exit: {exit_code}[/]")
+
+            elif step_type == "tool_call":
+                tool = step.get("tool", "unknown")
+                if full and step.get("full_args"):
+                    import json
+                    console.print(f"{prefix} [magenta]tool:[/] {tool}")
+                    console.print(f"       {json.dumps(step['full_args'], indent=2)}")
+                else:
+                    args = step.get("args_preview", "")
+                    console.print(f"{prefix} [magenta]tool:[/] {tool}({args})")
+
+            elif step_type == "tool_output":
+                output = step.get("output", "")
+                if not full:
+                    output = output[:100]
+                console.print(f"{prefix} [dim]→ {output}[/]")
+
+            elif step_type == "message":
+                if full and step.get("full_text"):
+                    console.print(f"{prefix} [green]response:[/]")
+                    console.print(f"       {step['full_text']}")
+                else:
+                    summary = step.get("summary", "")
+                    full_len = step.get("full_length", 0)
+                    console.print(f"{prefix} [green]response:[/] {summary}")
+                    if full_len > 200:
+                        console.print(f"       [dim]({full_len} chars total)[/]")
+
+        console.print()
+
     def do_continue(session_id: str, message: str, wait: bool = True):
         """
         Continue a conversation using CodexSessionManager.inject_message().
@@ -1872,6 +2070,17 @@ def interactive(
                 else:
                     do_show(args[0])
 
+            elif cmd in ("traj", "trajectory"):
+                if not args:
+                    console.print("  [red]Usage:[/] traj SESSION_ID [--full]")
+                else:
+                    full_mode = "--full" in args
+                    session_arg = [a for a in args if a != "--full"]
+                    if session_arg:
+                        do_trajectory(session_arg[0], full=full_mode)
+                    else:
+                        console.print("  [red]Usage:[/] traj SESSION_ID [--full]")
+
             elif cmd in ("c", "continue"):
                 # Sync continue - waits for response
                 if len(args) < 2: