fluxloop-cli 0.2.28__tar.gz → 0.2.29__tar.gz

{fluxloop_cli-0.2.28 → fluxloop_cli-0.2.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fluxloop-cli
-Version: 0.2.28
+Version: 0.2.29
 Summary: FluxLoop CLI for running agent simulations
 Author-email: FluxLoop Team <team@fluxloop.dev>
 License: Apache-2.0

{fluxloop_cli-0.2.28 → fluxloop_cli-0.2.29}/fluxloop_cli/__init__.py

@@ -2,7 +2,7 @@
 FluxLoop CLI - Command-line interface for running agent simulations.
 """
 
-__version__ = "0.2.28"
+__version__ = "0.2.29"
 
 from .main import app
 

{fluxloop_cli-0.2.28 → fluxloop_cli-0.2.29}/fluxloop_cli/commands/run.py

@@ -3,10 +3,9 @@ Run command for executing experiments and simulations.
 """
 
 import asyncio
-import json
 import sys
 from pathlib import Path
-from typing import Optional
+from typing import Callable, Optional
 
 import typer
 from rich.console import Console
@@ -28,16 +27,6 @@ app = typer.Typer()
 console = Console()
 
 
-def _emit_progress_event(event: str, **payload: object) -> None:
-    """Emit a structured progress event to stderr for machine consumption."""
-    data = {"event": event, **payload}
-    try:
-        print(json.dumps(data, default=str), file=sys.stderr, flush=True)
-    except Exception:
-        # Fall back to repr if serialization fails
-        print({"event": event, **{k: repr(v) for k, v in payload.items()}}, file=sys.stderr, flush=True)
-
-
 @app.command()
 def experiment(
     config_file: Path = typer.Option(
@@ -124,6 +113,11 @@ def experiment(
         "--dry-run",
         help="Show what would be run without executing",
     ),
+    display: bool = typer.Option(
+        True,
+        "--display/--no-display",
+        help="Show rich console output (disable for plain log streaming)",
+    ),
 ):
     """
     Run an experiment based on configuration file.
@@ -239,19 +233,8 @@ def experiment(
     
     console.print(summary)
 
-    _emit_progress_event(
-        "experiment_summary",
-        name=config.name,
-        iterations=config.iterations,
-        personas=len(config.personas),
-        total_runs=total_runs,
-        multi_turn_enabled=bool(config.multi_turn and config.multi_turn.enabled),
-        output_dir=config.output_directory,
-    )
-    
     if dry_run:
         console.print("\n[yellow]Dry run mode - no execution will occur[/yellow]")
-        _emit_progress_event("experiment_status", status="dry_run", name=config.name)
         return
     
     # Confirm execution
@@ -265,128 +248,134 @@ def experiment(
             f"\nThis will execute {total_runs} runs."
         )
 
-    _emit_progress_event(
-        "experiment_ready",
-        name=config.name,
-        total_runs=total_runs,
-    )
-
     if not typer.confirm("Continue?"):
-        _emit_progress_event("experiment_status", status="aborted", reason="user_declined", name=config.name)
         raise typer.Abort()
     
     # Create runner
     # Run experiment with progress tracking
     console.print("\n[bold green]▶️ Starting experiment...[/bold green]\n")
 
-    _emit_progress_event("experiment_started", name=config.name, total_runs=total_runs)
-
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        BarColumn(),
-        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
-        TimeRemainingColumn(),
-        TextColumn("({task.completed} of {task.total})"),
-        console=console,
-    ) as progress:
-        # Create main task
-        main_task = progress.add_task(
-            f"Running {config.name}",
-            total=total_runs,
-        )
-        multi_turn_total = (
-            config.multi_turn.max_turns
-            if config.multi_turn and config.multi_turn.max_turns
-            else None
-        )
-        turn_task = progress.add_task(
-            "[cyan]Turn 0/0",
-            total=multi_turn_total or 1,
-            visible=False,
-        )
+    def _execute_with_callbacks(
+        progress_callback: Optional[Callable[[], None]],
+        turn_progress_callback: Optional[Callable[[int, int, Optional[str]], None]],
+    ):
+        try:
+            return asyncio.run(
+                runner.run_experiment(
+                    progress_callback=progress_callback,
+                    turn_progress_callback=turn_progress_callback,
+                )
+            )
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Experiment interrupted by user[/yellow]")
+            raise typer.Exit(1)
+        except Exception as e:
+            console.print(f"\n[red]Error during experiment:[/red] {e}")
+            if "--debug" in sys.argv:
+                console.print_exception()
+            raise typer.Exit(1)
 
-        def _progress_callback():
-            progress.advance(main_task)
-            task = progress.tasks[main_task]
-            _emit_progress_event(
-                "run_progress",
-                completed=int(task.completed),
-                total=int(task.total or 0),
-                description=task.description,
-                experiment=config.name,
+    if display and console.is_terminal:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            TimeRemainingColumn(),
+            TextColumn("({task.completed} of {task.total})"),
+            console=console,
+        ) as progress:
+            main_task = progress.add_task(
+                f"Running {config.name}",
+                total=total_runs,
+            )
+            multi_turn_total = (
+                config.multi_turn.max_turns
+                if config.multi_turn and config.multi_turn.max_turns
+                else None
+            )
+            turn_task = progress.add_task(
+                "[cyan]Turn 0/0",
+                total=multi_turn_total or 1,
+                visible=False,
             )
 
-        def _turn_progress_callback(
-            current_turn: int,
-            total_turns: int,
-            message: Optional[str] = None,
-        ) -> None:
-            total = total_turns or 1
-            clamped_turn = max(0, current_turn)
-            if message is None:
-                completed = min(clamped_turn, total)
-                description = f"[cyan]Turn {min(clamped_turn, total)}/{total}: complete"
+            def _progress_callback() -> None:
+                progress.advance(main_task)
+
+            def _turn_progress_callback(
+                current_turn: int,
+                total_turns: int,
+                message: Optional[str] = None,
+            ) -> None:
+                total = total_turns or 1
+                clamped_turn = max(0, current_turn)
+                if message is None:
+                    completed = min(clamped_turn, total)
+                    description = f"[cyan]Turn {min(clamped_turn, total)}/{total}: complete"
+                    progress.update(
+                        turn_task,
+                        total=total,
+                        completed=completed,
+                        description=description,
+                        visible=False,
+                    )
+                    return
+
+                if not progress.tasks[turn_task].visible:
+                    progress.update(turn_task, visible=True)
+
+                preview = message.replace("\n", " ")
+                if len(preview) > 40:
+                    preview = preview[:37] + "..."
+
+                completed = max(0, min(clamped_turn - 1, total))
+                description = f"[cyan]Turn {min(clamped_turn, total)}/{total}: {preview}"
                 progress.update(
                     turn_task,
                     total=total,
                     completed=completed,
                     description=description,
-                    visible=False,
                 )
-                _emit_progress_event(
-                    "turn_progress",
-                    state="complete",
-                    current=min(clamped_turn, total),
-                    total=total,
-                experiment=config.name,
-                )
-                return
-
-            if not progress.tasks[turn_task].visible:
-                progress.update(turn_task, visible=True)
-
-            preview = message.replace("\n", " ")
-            if len(preview) > 40:
-                preview = preview[:37] + "..."
 
-            completed = max(0, min(clamped_turn - 1, total))
-            description = f"[cyan]Turn {min(clamped_turn, total)}/{total}: {preview}"
+            results = _execute_with_callbacks(_progress_callback, _turn_progress_callback)
+    else:
+        completed_runs = 0
 
-            progress.update(
-                turn_task,
-                total=total,
-                completed=completed,
-                description=description,
-            )
-            _emit_progress_event(
-                "turn_progress",
-                state="in_progress",
-                current=clamped_turn,
-                total=total,
-                preview=preview,
-                experiment=config.name,
+        def _progress_callback() -> None:
+            nonlocal completed_runs
+            completed_runs += 1
+            print(
+                f"[fluxloop] run progress {completed_runs}/{total_runs}",
+                flush=True,
             )
 
-        # Run experiment
-        try:
-            results = asyncio.run(
-                runner.run_experiment(
-                    progress_callback=_progress_callback,
-                    turn_progress_callback=_turn_progress_callback,
+        def _turn_progress_callback(
+            current_turn: int,
+            total_turns: int,
+            message: Optional[str] = None,
+        ) -> None:
+            total = total_turns or 1
+            clamped_turn = max(0, current_turn)
+            if message:
+                preview = message.replace("\n", " ")
+                if len(preview) > 80:
+                    preview = preview[:77] + "..."
+                print(
+                    f"[fluxloop] turn progress {min(clamped_turn, total)}/{total}: {preview}",
+                    flush=True,
                 )
-            )
-        except KeyboardInterrupt:
-            console.print("\n[yellow]Experiment interrupted by user[/yellow]")
-            _emit_progress_event("experiment_status", status="interrupted", name=config.name)
-            raise typer.Exit(1)
-        except Exception as e:
-            console.print(f"\n[red]Error during experiment:[/red] {e}")
-            # Debug mode - show full traceback
-            if "--debug" in sys.argv:
-                console.print_exception()
-            _emit_progress_event("experiment_status", status="error", error=str(e), name=config.name)
-            raise typer.Exit(1)
+            else:
+                print(
+                    f"[fluxloop] turn progress {min(clamped_turn, total)}/{total}: complete",
+                    flush=True,
+                )
+
+        print(
+            f"[fluxloop] running {config.name} ({total_runs} total runs)",
+            flush=True,
+        )
+        results = _execute_with_callbacks(_progress_callback, _turn_progress_callback)
     
     config.set_resolved_input_count(results.get("input_count", config.get_input_count()))
 
@@ -399,15 +388,6 @@ def experiment(
         )
 
     _display_results(results)
-    _emit_progress_event(
-        "experiment_status",
-        status="completed",
-        name=config.name,
-        total_runs=results.get("total_runs", total_runs),
-        successful=results.get("successful"),
-        failed=results.get("failed"),
-        success_rate=results.get("success_rate"),
-    )
 
 
 @app.command()

{fluxloop_cli-0.2.28 → fluxloop_cli-0.2.29}/fluxloop_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fluxloop-cli
-Version: 0.2.28
+Version: 0.2.29
 Summary: FluxLoop CLI for running agent simulations
 Author-email: FluxLoop Team <team@fluxloop.dev>
 License: Apache-2.0

{fluxloop_cli-0.2.28 → fluxloop_cli-0.2.29}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fluxloop-cli"
-version = "0.2.28"
+version = "0.2.29"
 description = "FluxLoop CLI for running agent simulations"
 authors = [
     {name = "FluxLoop Team", email = "team@fluxloop.dev"}