behave-runner 0.1.0__py3-none-any.whl

behave_runner/__init__.py

@@ -0,0 +1,5 @@
+"""behave-runner — CLI completa para Behave con subcomandos."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"

behave_runner/__main__.py

@@ -0,0 +1,14 @@
+"""Entry point for python -m behave_runner."""
+
+from __future__ import annotations
+
+from behave_runner.cli.app import app
+
+
+def main() -> None:
+    """Console script entry point."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

behave_runner/cli/app.py

@@ -0,0 +1,69 @@
+"""CLI app for behave-runner."""
+
+from __future__ import annotations
+
+import typer
+
+from behave_runner import __version__
+from behave_runner.commands.config_cmd import config_app
+from behave_runner.commands.doctor import doctor_command
+from behave_runner.commands.format_cmd import format_command
+from behave_runner.commands.generate import generate_app
+from behave_runner.commands.impact import impact_command
+from behave_runner.commands.init import init_command
+from behave_runner.commands.lint import lint_command
+from behave_runner.commands.list_cmd import list_command
+from behave_runner.commands.open_cmd import open_command
+from behave_runner.commands.record import record_command
+from behave_runner.commands.report import report_app
+from behave_runner.commands.run import run_command
+from behave_runner.commands.select import select_command
+from behave_runner.commands.steps import steps_app
+from behave_runner.commands.trace import trace_app
+from behave_runner.commands.watch import watch_command
+
+app = typer.Typer(
+    name="behave-runner",
+    help="CLI completa para Behave con subcomandos.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        print(__version__)
+        raise typer.Exit
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        None,
+        "--version",
+        callback=version_callback,
+        is_eager=True,
+        help="Show version and exit.",
+    ),
+) -> None:
+    """behave-runner — CLI completa para Behave con subcomandos."""
+    pass
+
+
+app.command(name="run")(run_command)
+app.command(name="select")(select_command)
+app.command(name="list")(list_command)
+app.command(name="format")(format_command)
+app.command(name="lint")(lint_command)
+app.command(name="doctor")(doctor_command)
+app.command(name="init")(init_command)
+app.add_typer(report_app, name="report")
+app.add_typer(generate_app, name="generate")
+app.add_typer(trace_app, name="trace")
+app.command(name="watch")(watch_command)
+app.command(name="impact")(impact_command)
+app.add_typer(steps_app, name="steps")
+app.command(name="impact")(impact_command)
+app.command(name="record")(record_command)
+app.command(name="open")(open_command)
+app.add_typer(config_app, name="config")

behave_runner/commands/config_cmd.py

@@ -0,0 +1,173 @@
+"""Config command for behave-runner CLI."""
+
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from behave_runner.core.config import load_config
+
+console = Console()
+
+config_app = typer.Typer(
+    name="config",
+    help="Manage behave-runner configuration.",
+    no_args_is_help=True,
+)
+
+
+def _find_pyproject() -> Path:
+    """Find pyproject.toml in the current directory."""
+    pyproject = Path.cwd() / "pyproject.toml"
+    if not pyproject.exists():
+        console.print("[red]Error: pyproject.toml not found in current directory.[/red]")
+        raise typer.Exit(1)
+    return pyproject
+
+
+def _read_toml(path: Path) -> dict[str, Any]:
+    """Read a TOML file and return its contents."""
+    with path.open("rb") as f:
+        return tomllib.load(f)
+
+
+def _write_toml_section(path: Path, data: dict[str, Any]) -> None:
+    """Append or update [tool.behave-runner] section preserving the rest."""
+    content = path.read_text(encoding="utf-8")
+    section_header = "[tool.behave-runner]"
+
+    if section_header in content:
+        console.print("[yellow]Section [tool.behave-runner] already exists.[/yellow]")
+        return
+
+    lines = content.splitlines(keepends=True)
+    new_lines: list[str] = []
+    inserted = False
+
+    for line in lines:
+        new_lines.append(line)
+        if not inserted and line.strip().startswith("[tool."):
+            new_lines.append(f"\n{section_header}\n")
+            for key, value in data.items():
+                new_lines.append(f"{key} = {_format_value(value)}\n")
+            inserted = True
+
+    if not inserted:
+        if new_lines and not new_lines[-1].endswith("\n"):
+            new_lines[-1] += "\n"
+        new_lines.append(f"\n{section_header}\n")
+        for key, value in data.items():
+            new_lines.append(f"{key} = {_format_value(value)}\n")
+
+    path.write_text("".join(new_lines), encoding="utf-8")
+
+
+def _set_config_value(path: Path, key: str, value: str) -> None:
+    """Set a key in the [tool.behave-runner] section."""
+    content = path.read_text(encoding="utf-8")
+    section_header = "[tool.behave-runner]"
+
+    if section_header not in content:
+        _write_toml_section(path, {key: _parse_value(value)})
+        return
+
+    lines = content.splitlines(keepends=True)
+    new_lines: list[str] = []
+    in_section = False
+    key_found = False
+
+    for line in lines:
+        stripped = line.strip()
+
+        if stripped == section_header:
+            in_section = True
+            new_lines.append(line)
+            continue
+
+        if in_section and stripped.startswith("[") and stripped != section_header:
+            if not key_found:
+                new_lines.append(f"{key} = {_format_value(_parse_value(value))}\n")
+                key_found = True
+            in_section = False
+
+        if (
+            in_section
+            and stripped.startswith(f"{key} ")
+            or (in_section and stripped.startswith(f"{key}="))
+        ):
+            new_lines.append(f"{key} = {_format_value(_parse_value(value))}\n")
+            key_found = True
+            continue
+
+        new_lines.append(line)
+
+    if in_section and not key_found:
+        new_lines.append(f"{key} = {_format_value(_parse_value(value))}\n")
+
+    path.write_text("".join(new_lines), encoding="utf-8")
+
+
+def _format_value(value: Any) -> str:
+    """Format a Python value as a TOML literal."""
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, float):
+        return str(value)
+    return f'"{value}"'
+
+
+def _parse_value(value: str) -> Any:
+    """Parse a string value into a Python type for TOML."""
+    if value.lower() in ("true", "false"):
+        return value.lower() == "true"
+    try:
+        return int(value)
+    except ValueError:
+        pass
+    try:
+        return float(value)
+    except ValueError:
+        pass
+    return value.strip("\"'")
+
+
+@config_app.command(name="show")
+def config_show() -> None:
+    """Show current behave-runner configuration."""
+    config = load_config()
+    if not config:
+        console.print("[yellow]No [tool.behave-runner] configuration found.[/yellow]")
+        return
+
+    table = Table(title="behave-runner configuration")
+    table.add_column("Key", style="cyan")
+    table.add_column("Value", style="green")
+    for key, value in sorted(config.items()):
+        table.add_row(key, str(value))
+    console.print(table)
+
+
+@config_app.command(name="init")
+def config_init() -> None:
+    """Create [tool.behave-runner] section in pyproject.toml."""
+    pyproject = _find_pyproject()
+    _write_toml_section(pyproject, {})
+    console.print("[green]Created [tool.behave-runner] section in pyproject.toml[/green]")
+
+
+@config_app.command(name="set")
+def config_set(
+    key: str = typer.Argument(..., help="Configuration key to set."),
+    value: str = typer.Argument(..., help="Value to assign."),
+) -> None:
+    """Set a configuration value in [tool.behave-runner]."""
+    pyproject = _find_pyproject()
+    _set_config_value(pyproject, key, value)
+    console.print(f"[green]Set {key} = {value}[/green]")

behave_runner/commands/doctor.py

@@ -0,0 +1,30 @@
+"""Doctor command for behave-runner CLI."""
+
+from __future__ import annotations
+
+import subprocess
+
+import typer
+from rich.console import Console
+
+from behave_runner.core.deps import check_optional
+
+console = Console()
+
+
+def doctor_command(
+    args: list[str] = typer.Argument(None, help="Arguments to pass to behave-doctor."),
+) -> None:
+    """Run behave-doctor to diagnose and fix common issues."""
+    if not check_optional("doctor", "behave_doctor", "doctor"):
+        raise typer.Exit(2)
+
+    cmd = ["behave-doctor", *(args or [])]
+    try:
+        result = subprocess.run(cmd, check=False)  # noqa: S603
+        raise typer.Exit(result.returncode)
+    except FileNotFoundError:
+        console.print(
+            "[red]Error: behave-doctor not found. Install with: pip install behave-doctor[/red]"
+        )
+        raise typer.Exit(2) from None

behave_runner/commands/format_cmd.py

@@ -0,0 +1,41 @@
+"""Format command for behave-runner CLI."""
+
+from __future__ import annotations
+
+import subprocess
+
+import typer
+from rich.console import Console
+
+from behave_runner.core.deps import check_optional
+
+console = Console()
+
+
+def format_command(
+    args: list[str] = typer.Argument(None, help="Arguments to pass to behave-format."),
+    check: bool = typer.Option(False, "--check", help="Check only, don't modify files."),
+    diff: bool = typer.Option(False, "--diff", help="Show diff of changes."),
+    in_place: bool = typer.Option(False, "--in-place", help="Modify files in place."),
+) -> None:
+    """Run behave-format to format feature files."""
+    if not check_optional("format", "behave_format", "format"):
+        raise typer.Exit(2)
+
+    cmd = ["behave-format"]
+    if check:
+        cmd.append("--check")
+    if diff:
+        cmd.append("--diff")
+    if in_place:
+        cmd.append("--in-place")
+    cmd.extend(args or [])
+
+    try:
+        result = subprocess.run(cmd, check=False)  # noqa: S603
+        raise typer.Exit(result.returncode)
+    except FileNotFoundError:
+        console.print(
+            "[red]Error: behave-format not found. Install with: pip install behave-format[/red]"
+        )
+        raise typer.Exit(2) from None

behave_runner/commands/generate.py

@@ -0,0 +1,53 @@
+"""Generate command for behave-runner CLI."""
+
+from __future__ import annotations
+
+import subprocess
+
+import typer
+from rich.console import Console
+
+from behave_runner.core.deps import check_optional
+
+console = Console()
+
+generate_app = typer.Typer(
+    name="generate",
+    help="Generate step definitions and feature files using behave-gen.",
+    no_args_is_help=True,
+)
+
+
+def _run_behave_gen(cmd: list[str]) -> None:
+    """Delegate to behave-gen via subprocess."""
+    if not check_optional("gen", "behave_gen", "generate"):
+        raise typer.Exit(2)
+
+    try:
+        result = subprocess.run(cmd, check=False)  # noqa: S603
+        raise typer.Exit(result.returncode)
+    except FileNotFoundError:
+        console.print(
+            "[red]Error: behave-gen not found. Install with: pip install behave-gen[/red]"
+        )
+        raise typer.Exit(2) from None
+
+
+@generate_app.command(name="step")
+def generate_step(
+    lib: str = typer.Option(..., "--lib", help="Step library name (e.g. http, auth)."),
+) -> None:
+    """Generate step definitions from a step library."""
+    _run_behave_gen(["behave-gen", "add", "steps", "--lib", lib])
+
+
+@generate_app.command(name="feature")
+def generate_feature(
+    name: str = typer.Argument(..., help="Feature name (without extension)."),
+    tags: str | None = typer.Option(None, "--tags", help="Comma or space separated tags."),
+) -> None:
+    """Generate a feature file skeleton."""
+    cmd = ["behave-gen", "add", "feature", name]
+    if tags:
+        cmd.extend(["--tags", tags])
+    _run_behave_gen(cmd)

behave_runner/commands/impact.py

@@ -0,0 +1,50 @@
+"""Impact command for behave-runner CLI."""
+
+from __future__ import annotations
+
+import subprocess
+
+import typer
+from rich.console import Console
+
+from behave_runner.core.deps import check_optional
+from behave_runner.core.orchestrator import RunConfig, run
+
+console = Console()
+
+
+def impact_command(
+    path: str = typer.Argument(".", help="Project root directory to analyze."),
+    fmt: str = typer.Option("text", "--format", help="Output format: text, json, sarif."),
+    run_affected: bool = typer.Option(
+        False, "--run", help="Run affected scenarios after detecting them."
+    ),
+) -> None:
+    """Detect scenarios affected by code changes using behave-doctor."""
+    if not check_optional("doctor", "behave_doctor", "impact"):
+        raise typer.Exit(2)
+
+    cmd = ["behave-doctor", "scan", "--format", fmt, path]
+
+    try:
+        result = subprocess.run(  # noqa: S603
+            cmd, check=False, capture_output=run_affected, text=True
+        )
+    except FileNotFoundError:
+        console.print(
+            "[red]Error: behave-doctor not found. Install with: pip install behave-doctor[/red]"
+        )
+        raise typer.Exit(2) from None
+
+    if run_affected and result.stdout:
+        names = [line.strip() for line in result.stdout.strip().splitlines() if line.strip()]
+        if names:
+            console.print(f"[cyan]Running {len(names)} affected scenarios...[/cyan]")
+            for name in names:
+                config = RunConfig(features=[path], name=[name])
+                run(config)
+        else:
+            console.print("[yellow]No affected scenarios to run.[/yellow]")
+            raise typer.Exit(result.returncode)
+
+    raise typer.Exit(result.returncode)

behave_runner/commands/init.py

@@ -0,0 +1,37 @@
+"""Init command for behave-runner CLI."""
+
+from __future__ import annotations
+
+import subprocess
+
+import typer
+from rich.console import Console
+
+from behave_runner.core.deps import check_optional
+
+console = Console()
+
+
+def init_command(
+    name: str | None = typer.Option(
+        None, "--name", help="Project name for the generated structure."
+    ),
+    args: list[str] = typer.Argument(None, help="Additional arguments for behave-gen."),
+) -> None:
+    """Initialize a new behave project structure using behave-gen."""
+    if not check_optional("gen", "behave_gen", "init"):
+        raise typer.Exit(2)
+
+    cmd = ["behave-gen", "init"]
+    if name:
+        cmd.extend(["--name", name])
+    cmd.extend(args or [])
+
+    try:
+        result = subprocess.run(cmd, check=False)  # noqa: S603
+        raise typer.Exit(result.returncode)
+    except FileNotFoundError:
+        console.print(
+            "[red]Error: behave-gen not found. Install with: pip install behave-gen[/red]"
+        )
+        raise typer.Exit(2) from None

behave_runner/commands/lint.py

@@ -0,0 +1,30 @@
+"""Lint command for behave-runner CLI."""
+
+from __future__ import annotations
+
+import subprocess
+
+import typer
+from rich.console import Console
+
+from behave_runner.core.deps import check_optional
+
+console = Console()
+
+
+def lint_command(
+    args: list[str] = typer.Argument(None, help="Arguments to pass to behave-lint."),
+) -> None:
+    """Run behave-lint static analysis on features."""
+    if not check_optional("lint", "behave_lint", "lint"):
+        raise typer.Exit(2)
+
+    cmd = [*args] if args else []
+    try:
+        result = subprocess.run(["behave-lint", *cmd], check=False)  # noqa: S603
+        raise typer.Exit(result.returncode)
+    except FileNotFoundError:
+        console.print(
+            "[red]Error: behave-lint not found. Install with: pip install behave-lint[/red]"
+        )
+        raise typer.Exit(2) from None

behave_runner/commands/list_cmd.py

@@ -0,0 +1,76 @@
+"""List command for behave-runner CLI."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import typer
+from behave_model import load_feature
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def _collect_scenarios(feature_paths: list[Path], tags: list[str]) -> list[dict[str, Any]]:
+    """Parse feature files and collect matching scenarios."""
+    scenarios: list[dict[str, Any]] = []
+    for fp in feature_paths:
+        if fp.is_dir():
+            feature_files = sorted(fp.rglob("*.feature"))
+        elif fp.is_file() and fp.suffix == ".feature":
+            feature_files = [fp]
+        else:
+            continue
+        for ff in feature_files:
+            feature = load_feature(str(ff))
+            for scenario in feature.scenarios:
+                if _matches_tags(scenario.tag_names, tags):
+                    scenarios.append(
+                        {
+                            "feature": feature.name,
+                            "scenario": scenario.name,
+                            "location": str(scenario.location),
+                            "tags": list(scenario.tag_names),
+                        }
+                    )
+    return scenarios
+
+
+def _matches_tags(scenario_tags: list[str], filter_tags: list[str]) -> bool:
+    """Check if scenario matches all filter tags."""
+    if not filter_tags:
+        return True
+    return all(tag in scenario_tags for tag in filter_tags)
+
+
+def list_command(
+    features: list[Path] = typer.Argument(
+        default=None,
+        help="Paths to feature files or directories.",
+    ),
+    tags: list[str] = typer.Option([], "--tags", "-t", help="Filter by tags."),
+    fmt: str = typer.Option("text", "--format", help="Output format: text, json."),
+) -> None:
+    """List scenarios without executing them."""
+    feature_paths = features if features else [Path("features")]
+    scenarios = _collect_scenarios(feature_paths, tags)
+
+    if fmt == "json":
+        print(json.dumps(scenarios, indent=2))
+    else:
+        table = Table(title="Scenarios")
+        table.add_column("Feature")
+        table.add_column("Scenario")
+        table.add_column("Location")
+        table.add_column("Tags")
+        for s in scenarios:
+            table.add_row(
+                s["feature"],
+                s["scenario"],
+                s["location"],
+                ", ".join(s["tags"]),
+            )
+        console.print(table)

behave_runner/commands/open_cmd.py

@@ -0,0 +1,65 @@
+"""Open command for behave-runner CLI."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Literal
+
+import typer
+from rich.console import Console
+
+from behave_runner.core.deps import check_optional
+from behave_runner.core.output import find_latest_report
+from behave_runner.utils import open_in_browser
+
+console = Console()
+
+TargetType = Literal["report", "trace"]
+
+
+def open_command(
+    target: TargetType = typer.Argument(
+        "report",
+        help="What to open: 'report' (default) or 'trace'.",
+    ),
+    output: Path = typer.Option(
+        Path("reports"),
+        "--output",
+        help="Directory containing reports.",
+    ),
+) -> None:
+    """Open the latest report or trace viewer in the browser."""
+    if target == "trace":
+        _open_trace()
+        return
+
+    _open_report(output)
+
+
+def _open_report(output: Path) -> None:
+    """Find and open the latest report in the browser."""
+    report_file = find_latest_report(output)
+    if report_file is None:
+        console.print("[yellow]No reports found.[/yellow]")
+        return
+    console.print(f"[green]Opening: {report_file}[/green]")
+    open_in_browser(str(report_file.resolve()))
+
+
+def _open_trace() -> None:
+    """Open the trace viewer via behave-trace."""
+    if not check_optional("trace", "behave_trace", "trace"):
+        raise typer.Exit(2)
+
+    try:
+        result = subprocess.run(
+            ["behave-trace", "show"],
+            check=False,  # noqa: S603
+        )
+        raise typer.Exit(result.returncode)
+    except FileNotFoundError:
+        console.print(
+            "[red]Error: behave-trace not found. Install with: pip install behave-trace[/red]"
+        )
+        raise typer.Exit(2) from None