tactus 0.33.0__py3-none-any.whl → 0.34.0__py3-none-any.whl

tactus/cli/app.py

@@ -31,7 +31,6 @@ from tactus.validation import TactusValidator, ValidationMode
 from tactus.formatting import TactusFormatter, FormattingError
 from tactus.adapters.memory import MemoryStorage
 from tactus.adapters.file_storage import FileStorage
-from tactus.adapters.cli_hitl import CLIHITLHandler
 
 # Setup rich console for pretty output
 console = Console()
@@ -594,8 +593,8 @@ def run(
         console.print(f"[red]Error:[/red] Unknown storage backend: {storage}")
         raise typer.Exit(1)
 
-    # Setup HITL handler
-    hitl_handler = CLIHITLHandler(console=console)
+    # HITL handler will be set up later after procedure_id is known
+    hitl_handler = None
 
     # Load configuration cascade
     from tactus.core.config_manager import ConfigManager
@@ -627,6 +626,10 @@ def run(
     if sandbox is not None:
         # CLI flag overrides config
         sandbox_config_dict["enabled"] = sandbox
+    else:
+        # CLI default: require sandbox unless explicitly disabled
+        if sandbox_config_dict.get("enabled") is None:
+            sandbox_config_dict["enabled"] = True
     if sandbox_network is not None:
         sandbox_config_dict["network"] = sandbox_network
     if sandbox_broker_host is not None:
@@ -698,6 +701,23 @@ def run(
 
     # Create runtime
     procedure_id = f"cli-{workflow_file.stem}"
+
+    # Setup HITL handler - use new ControlLoopHandler with default channels
+    from tactus.adapters.channels import load_default_channels
+    from tactus.adapters.channels.cli import CLIControlChannel
+    from tactus.adapters.control_loop import ControlLoopHandler, ControlLoopHITLAdapter
+
+    # Load default channels (CLI if tty, IPC always)
+    # Then add CLI with custom console if not already present
+    channels = load_default_channels(procedure_id=procedure_id)
+
+    # If CLI channel not already loaded (because not tty), add it with custom console
+    if not any(c.channel_id == "cli" for c in channels):
+        channels.insert(0, CLIControlChannel(console=console))
+
+    control_handler = ControlLoopHandler(channels=channels, storage=storage_backend)
+    hitl_handler = ControlLoopHITLAdapter(control_handler)
+
     runtime = TactusRuntime(
         procedure_id=procedure_id,
         storage_backend=storage_backend,
@@ -800,7 +820,48 @@ def run(
                     console.print(f"[dim]{sandbox_result.traceback}[/dim]")
         else:
             # Execute directly (non-sandboxed)
-            result = asyncio.run(runtime.execute(source_content, context, format=file_format))
+            try:
+                result = asyncio.run(runtime.execute(source_content, context, format=file_format))
+            except Exception as e:
+                from tactus.core.exceptions import ProcedureWaitingForHuman
+
+                # Check both the exception itself and its __cause__
+                console.print(f"[dim]DEBUG: Caught exception type: {type(e).__name__}[/dim]")
+                console.print(
+                    f"[dim]DEBUG: Exception __cause__ type: {type(e.__cause__).__name__ if e.__cause__ else 'None'}[/dim]"
+                )
+                console.print(
+                    f"[dim]DEBUG: Is ProcedureWaitingForHuman: {isinstance(e, ProcedureWaitingForHuman)}[/dim]"
+                )
+                console.print(
+                    f"[dim]DEBUG: __cause__ is ProcedureWaitingForHuman: {isinstance(e.__cause__, ProcedureWaitingForHuman) if e.__cause__ else False}[/dim]"
+                )
+
+                if isinstance(e, ProcedureWaitingForHuman):
+                    # Direct exception
+                    console.print(
+                        "\n[yellow]⏸ Procedure paused - waiting for human response[/yellow]"
+                    )
+                    console.print(f"[dim]Message ID: {e.pending_message_id}[/dim]")
+                    console.print("\n[cyan]The procedure has been paused and is waiting for input.")
+                    console.print(
+                        "To resume, run the procedure again or provide a response via another channel.[/cyan]\n"
+                    )
+                    return
+                elif e.__cause__ and isinstance(e.__cause__, ProcedureWaitingForHuman):
+                    # Wrapped exception
+                    console.print(
+                        "\n[yellow]⏸ Procedure paused - waiting for human response[/yellow]"
+                    )
+                    console.print(f"[dim]Message ID: {e.__cause__.pending_message_id}[/dim]")
+                    console.print("\n[cyan]The procedure has been paused and is waiting for input.")
+                    console.print(
+                        "To resume, run the procedure again or provide a response via another channel.[/cyan]\n"
+                    )
+                    return
+                else:
+                    # Re-raise other exceptions
+                    raise
 
         if result["success"]:
             console.print("\n[green]✓ Procedure completed successfully[/green]\n")
@@ -899,6 +960,7 @@ def sandbox_rebuild(
     """
     from pathlib import Path
     from tactus.sandbox import is_docker_available, DockerManager
+    from tactus.sandbox.docker_manager import resolve_dockerfile_path
     import tactus
 
     # Check Docker availability
@@ -909,7 +971,7 @@ def sandbox_rebuild(
 
     # Get Tactus package path for build context
     tactus_path = Path(tactus.__file__).parent.parent
-    dockerfile_path = tactus_path / "tactus" / "docker" / "Dockerfile"
+    dockerfile_path, build_mode = resolve_dockerfile_path(tactus_path)
 
     if not dockerfile_path.exists():
         console.print(f"[red]Error:[/red] Dockerfile not found: {dockerfile_path}")
@@ -933,6 +995,10 @@ def sandbox_rebuild(
     console.print(f"[blue]Building sandbox image:[/blue] {manager.full_image_name}")
     console.print(f"[dim]Version: {version}[/dim]")
     console.print(f"[dim]Context: {tactus_path}[/dim]\n")
+    if build_mode == "pypi":
+        console.print(
+            "[yellow]No source tree detected; building image by installing tactus from PyPI.[/yellow]"
+        )
 
     success, message = manager.build_image(
         dockerfile_path=dockerfile_path,
@@ -1423,7 +1489,10 @@ def test(
             evaluator = TactusEvaluationRunner(
                 procedure_file, mock_tools=mock_tools, params=test_params
             )
-            evaluator.setup(result.registry.gherkin_specifications)
+            evaluator.setup(
+                result.registry.gherkin_specifications,
+                custom_steps_dict=result.registry.custom_steps,
+            )
 
             if scenario:
                 eval_results = [evaluator.evaluate_scenario(scenario, runs, parallel)]
@@ -1436,7 +1505,10 @@ def test(
         else:
             # Run standard test
             runner = TactusTestRunner(procedure_file, mock_tools=mock_tools, params=test_params)
-            runner.setup(result.registry.gherkin_specifications)
+            runner.setup(
+                result.registry.gherkin_specifications,
+                custom_steps_dict=result.registry.custom_steps,
+            )
 
             test_result = runner.run_tests(parallel=parallel, scenario_filter=scenario)
 
@@ -2211,6 +2283,195 @@ def trace_export(
         raise typer.Exit(1)
 
 
+# =============================================================================
+# Stdlib Commands
+# =============================================================================
+
+stdlib_app = typer.Typer(help="Manage Tactus standard library")
+app.add_typer(stdlib_app, name="stdlib")
+
+
+@stdlib_app.command("test")
+def stdlib_test(
+    module: Optional[str] = typer.Argument(
+        None, help="Specific module to test (e.g., 'classify', 'extract')"
+    ),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
+    parallel: bool = typer.Option(True, "--parallel/--no-parallel", help="Run in parallel"),
+):
+    """
+    Run BDD tests for standard library modules.
+
+    Examples:
+        tactus stdlib test              # Run all stdlib tests
+        tactus stdlib test classify     # Run only classify tests
+        tactus stdlib test extract      # Run only extract tests
+    """
+    import tactus
+    from tactus.validation import TactusValidator
+    from tactus.testing.test_runner import TactusTestRunner
+
+    # Find stdlib spec files
+    package_root = Path(tactus.__file__).parent
+    stdlib_tac_path = package_root / "stdlib" / "tac" / "tactus"
+
+    # Find all .spec.tac files
+    if module:
+        # Test specific module
+        spec_file = stdlib_tac_path / f"{module}.spec.tac"
+        if not spec_file.exists():
+            console.print(f"[red]Module spec not found: {spec_file}[/red]")
+            raise typer.Exit(1)
+        spec_files = [spec_file]
+    else:
+        # Test all modules
+        spec_files = list(stdlib_tac_path.glob("*.spec.tac"))
+
+    if not spec_files:
+        console.print("[yellow]No spec files found in stdlib[/yellow]")
+        raise typer.Exit(0)
+
+    console.print(f"[cyan]Found {len(spec_files)} spec file(s) to test[/cyan]")
+
+    total_passed = 0
+    total_failed = 0
+    failed_modules = []
+
+    validator = TactusValidator()
+
+    for spec_file in sorted(spec_files):
+        module_name = spec_file.stem.replace(".spec", "")
+        console.print(f"\n[bold]Testing: {module_name}[/bold]")
+
+        # Validate and load specs
+        result = validator.validate_file(str(spec_file))
+
+        if not result.valid:
+            console.print("  [red]✗ Validation failed[/red]")
+            for error in result.errors:
+                console.print(f"    {error.message}")
+            total_failed += 1
+            failed_modules.append(module_name)
+            continue
+
+        if not result.registry or not result.registry.gherkin_specifications:
+            console.print("  [yellow]⚠ No specifications found[/yellow]")
+            continue
+
+        # Run tests
+        try:
+            runner = TactusTestRunner(spec_file, mock_tools={}, params={})
+            runner.setup(
+                result.registry.gherkin_specifications,
+                custom_steps_dict=result.registry.custom_steps,
+            )
+
+            test_result = runner.run_tests(parallel=parallel, scenario_filter=None)
+
+            # Display results
+            passed = test_result.passed_scenarios
+            failed = test_result.failed_scenarios
+            total_passed += passed
+            total_failed += failed
+
+            if failed > 0:
+                console.print(f"  [red]✗ {passed} passed, {failed} failed[/red]")
+                for feature in test_result.features:
+                    for scenario in feature.scenarios:
+                        if scenario.status != "failed":
+                            continue
+                        console.print(f"    [red]Scenario failed:[/red] {scenario.name}")
+                        for step in scenario.steps:
+                            if step.status != "failed":
+                                continue
+                            error_detail = step.error_message or "Unknown failure"
+                            console.print(
+                                f"      [red]{step.keyword} {step.message}[/red]: {error_detail}"
+                            )
+                failed_modules.append(module_name)
+            else:
+                console.print(f"  [green]✓ {passed} scenarios passed[/green]")
+
+            runner.cleanup()
+
+        except Exception as e:
+            console.print(f"  [red]✗ Error: {e}[/red]")
+            if verbose:
+                console.print_exception()
+            total_failed += 1
+            failed_modules.append(module_name)
+
+    # Summary
+    console.print("\n" + "=" * 50)
+    console.print("[bold]Stdlib Test Summary[/bold]")
+    console.print(f"  Passed: [green]{total_passed}[/green]")
+    console.print(f"  Failed: [red]{total_failed}[/red]")
+
+    if failed_modules:
+        console.print(f"\n[red]Failed modules: {', '.join(failed_modules)}[/red]")
+        raise typer.Exit(1)
+
+    console.print("\n[green]All stdlib tests passed![/green]")
+
+
+# =============================================================================
+# Control Command
+# =============================================================================
+
+
+@app.command()
+def control(
+    socket_path: Optional[str] = typer.Option(
+        None,
+        "--socket",
+        "-s",
+        help="Path to runtime's Unix socket (default: auto-detect from /tmp/tactus-control-*.sock)",
+    ),
+    auto_respond: Optional[str] = typer.Option(
+        None, "--respond", "-r", help="Auto-respond with this value (for testing)"
+    ),
+):
+    """
+    Connect to running procedure and respond to control requests.
+
+    Opens an interactive session that connects to a running Tactus procedure
+    via Unix socket IPC. Control requests from Human.approve() and similar
+    calls will appear here, and you can respond to them.
+
+    This allows running the procedure in one terminal and responding to
+    control requests from another terminal.
+    """
+    from tactus.cli.control import main as control_main
+    import glob
+
+    # Auto-detect socket path if not provided
+    if socket_path is None:
+        # Look for sockets in /tmp/tactus-control-*.sock
+        socket_files = glob.glob("/tmp/tactus-control-*.sock")
+        if not socket_files:
+            console.print("[red]✗ No Tactus runtime sockets found[/red]")
+            console.print("\n[yellow]Make sure a Tactus procedure is running:[/yellow]")
+            console.print("  [dim]tactus run examples/90-hitl-simple.tac[/dim]")
+            raise typer.Exit(1)
+        elif len(socket_files) == 1:
+            socket_path = socket_files[0]
+            console.print(f"[dim]Auto-detected socket: {socket_path}[/dim]")
+        else:
+            console.print("[yellow]Multiple runtime sockets found:[/yellow]")
+            for i, path in enumerate(socket_files, 1):
+                console.print(f"  [{i}] {path}")
+            console.print()
+            selection = Prompt.ask(
+                "Select socket",
+                choices=[str(i) for i in range(1, len(socket_files) + 1)],
+                default="1",
+            )
+            socket_path = socket_files[int(selection) - 1]
+
+    # Run control CLI
+    asyncio.run(control_main(socket_path, auto_respond))
+
+
 def main():
     """Main entry point for the CLI."""
     # Load configuration before processing any commands
@@ -2228,6 +2489,8 @@ def main():
             "eval",
             "version",
             "ide",
+            "stdlib",
+            "control",
             "trace-list",
             "trace-show",
             "trace-export",