cmdbox-cli 1.0.0__py3-none-any.whl

cmdbox/cli/commands/command_run.py

@@ -0,0 +1,255 @@
+from typing import Annotated, Optional
+import logging
+
+import typer
+
+from cmdbox import container
+from cmdbox.cli.common.errors import make_cli_guard
+from cmdbox.cli.completions.commands import complete_command_aliases
+from cmdbox.cli.handlers.run_handler import (
+    run_preview_command,
+    RawRunContext,
+    run_run_command,
+)
+
+app = typer.Typer(no_args_is_help=True)
+
+cli_guard = make_cli_guard(container.get_console)
+
+log = logging.getLogger(__name__)
+
+
+@app.command(
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True}
+)
+@cli_guard
+def run(
+    alias: Annotated[
+        str,
+        typer.Argument(
+            help="The alias of the command to run.",
+            autocompletion=complete_command_aliases,
+        ),
+    ],
+    *,
+    preview_cmd: Annotated[
+        bool,
+        typer.Option(
+            "--preview",
+            "-p",
+            help="Output the command that will be executed without actually running it.",
+        ),
+    ] = False,
+    cwd: Annotated[
+        str | None,
+        typer.Option(
+            "--cwd", "-d", help="The working directory for the command execution."
+        ),
+    ] = None,
+    env: Annotated[
+        list[str] | None,
+        typer.Option("--env", help="The environment variables to set for the command."),
+    ] = None,
+    capture: Annotated[
+        bool,
+        typer.Option("--capture", "-c", help="Capture the command output."),
+    ] = False,
+    shell: Annotated[
+        str | None,
+        typer.Option(
+            "--shell", "-s", help="The shell to use for the command execution."
+        ),
+    ] = None,
+    timeout: Annotated[
+        int | None,
+        typer.Option(
+            "--timeout",
+            "-t",
+            help="The number of seconds before the process is killed.",
+        ),
+    ] = None,
+    emit: Annotated[
+        bool,
+        typer.Option(
+            "--emit",
+            "-e",
+            is_flag=True,
+            help="Print the command output to stdout instead of running it in a separate process. "
+            "You must then press enter to run the command in your current terminal window.",
+            hidden=True,
+        ),
+    ] = False,
+    verbose: Annotated[
+        Optional[bool],
+        typer.Option(
+            "--verbose/--no-verbose",
+            help="Outputs additional information alongside the command output.",
+        ),
+    ] = None,
+    ctx: typer.Context,
+) -> None:
+    """
+    Run stored commands by using their alias.
+    """
+    log.debug(
+        "run.run called. alias=%s, preview=%s, cwd_used=%s, env=%s, capture=%s, shell=%s, timeout=%s, emit=%s, verbose=%s",
+        alias,
+        preview_cmd,
+        cwd,
+        env,
+        capture,
+        shell,
+        timeout,
+        emit,
+        verbose,
+    )
+    if preview_cmd:
+        preview(
+            alias=alias,
+            cwd=cwd,
+            env=env,
+            capture=capture,
+            shell=shell,
+            timeout=timeout,
+            verbose=verbose,
+            ctx=ctx,
+        )
+        return
+
+    extra_args = ctx.args if ctx.args else ctx.meta.get("_extra_args", [])
+    runtime_vars = parse_runtime_vars(extra_args)
+
+    ctx = RawRunContext(
+        cwd=cwd,
+        env=env,
+        capture=capture,
+        shell=shell,
+        timeout=timeout,
+        emit=emit,
+        verbose=verbose,
+    )
+    run_run_command(
+        alias=alias,
+        runtime_vars=runtime_vars,
+        run_ctx=ctx,
+        get_run_service=container.get_run_service,
+        get_settings=container.get_settings,
+        get_console=container.get_console,
+    )
+
+
+@app.command(
+    "preview",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+)
+@cli_guard
+def preview(
+    alias: Annotated[
+        str,
+        typer.Argument(
+            help="The alias of the command to run.",
+            autocompletion=complete_command_aliases,
+        ),
+    ],
+    *,
+    cwd: Annotated[
+        str | None,
+        typer.Option(
+            "--cwd", "-d", help="The working directory for the command execution."
+        ),
+    ] = None,
+    env: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--env", "-e", help="The environment variables to set for the command."
+        ),
+    ] = None,
+    capture: Annotated[
+        bool,
+        typer.Option(
+            "--capture", "-c", is_flag=True, help="Capture the command output."
+        ),
+    ] = False,
+    shell: Annotated[
+        str | None,
+        typer.Option(
+            "--shell", "-s", help="The shell to use for the command execution."
+        ),
+    ] = None,
+    timeout: Annotated[
+        int | None,
+        typer.Option(
+            "--timeout",
+            "-t",
+            help="The number of seconds before the process is killed.",
+        ),
+    ] = None,
+    verbose: Annotated[
+        Optional[bool],
+        typer.Option(
+            "--verbose/--no-verbose",
+            help="Outputs additional information alongside the command output.",
+        ),
+    ] = None,
+    ctx: typer.Context,
+) -> None:
+    """
+    Output the command that will be executed without actually running it.
+    """
+    log.debug(
+        "run.preview called. alias=%s, cwd=%s, env=%s, capture=%s, shell=%s, timeout=%s, verbose=%s",
+        alias,
+        cwd,
+        env,
+        capture,
+        shell,
+        timeout,
+        verbose,
+    )
+    runtime_vars = parse_runtime_vars(ctx.args)
+    ctx = RawRunContext(
+        cwd=cwd, env=env, capture=capture, shell=shell, timeout=timeout, verbose=verbose
+    )
+    run_preview_command(
+        alias=alias,
+        runtime_vars=runtime_vars,
+        run_ctx=ctx,
+        get_run_service=container.get_run_service,
+        get_settings=container.get_settings,
+        get_console=container.get_console,
+    )
+
+
+def parse_runtime_vars(args: list[str]) -> dict[str, str]:
+    """
+    Parses a list of runtime arguments into a dictionary of key-value pairs.
+
+    This function processes a list of command-line arguments, extracting argument
+    keys prefixed with `--` and their corresponding values. Arguments without
+    values will not be included in the resulting dictionary. Unrecognized or
+    improperly formatted tokens are ignored.
+
+    Args:
+        args (list[str]): A list of strings, where each string represents a
+            command-line argument. Keys should be prefixed with `--` and may
+            optionally be followed by a value.
+
+    Returns:
+        dict[str, str]: A dictionary where keys are argument names (without the
+            `--` prefix) and values are their associated arguments. Only valid
+            key-value pairs are included.
+    """
+    result = {}
+    x = 0
+    while x < len(args):
+        token = args[x]
+        if token.startswith("--"):
+            key = token.lstrip("-")
+            if x + 1 < len(args) and not args[x + 1].startswith("--"):
+                result[key] = args[x + 1]
+                x += 2
+            else:
+                x += 1
+        else:
+            x += 1
+    return result

cmdbox/cli/commands/history.py

@@ -0,0 +1,109 @@
+import logging
+from typing import Annotated, Optional
+
+import typer
+
+from cmdbox import container
+from cmdbox.cli.handlers.history_handlers import (
+    run_history_list,
+    run_history_show,
+    run_history_rerun,
+    run_history_clear,
+    run_rerun_last,
+)
+from cmdbox.cli.common.errors import make_cli_guard
+
+app = typer.Typer(help="View and re-run command execution history.")
+
+cli_guard = make_cli_guard(container.get_console)
+
+log = logging.getLogger(__name__)
+
+
+@app.command("list")
+@cli_guard
+def history_list(
+    alias: Annotated[
+        Optional[str],
+        typer.Option("--alias", "-a", help="Filter history to a specific alias."),
+    ] = None,
+    limit: Annotated[
+        int,
+        typer.Option("--limit", "-l", help="The number of history entries to show."),
+    ] = 25,
+) -> None:
+    """List recent command executions."""
+    run_history_list(
+        alias=alias,
+        limit=limit,
+        get_history_service=container.get_history_service,
+        get_console=container.get_console,
+    )
+
+
+@app.command("show")
+@cli_guard
+def history_show(
+    ref: Annotated[
+        str,
+        typer.Argument(help="Entry index (from list) or ID prefix."),
+    ],
+) -> None:
+    """Show full details for a single history entry."""
+    run_history_show(
+        ref=ref,
+        get_history_service=container.get_history_service,
+        get_console=container.get_console,
+    )
+
+
+@app.command("rerun")
+@cli_guard
+def history_rerun(
+    ref: Annotated[
+        str,
+        typer.Argument(help="Entry index (from list) or ID prefix."),
+    ],
+) -> None:
+    """Re-execute a past command invocation using the same variables."""
+    run_history_rerun(
+        ref=ref,
+        get_history_service=container.get_history_service,
+        get_run_service=container.get_run_service,
+    )
+
+
+@app.command("clear")
+@cli_guard
+def history_clear(
+    alias: Annotated[
+        Optional[str],
+        typer.Option("--alias", "-a", help="Clear history only for a specific alias."),
+    ] = None,
+    yes: Annotated[
+        bool,
+        typer.Option(
+            "--yes",
+            "-y",
+            help="Skip confirmation prompt.",
+        ),
+    ] = False,
+) -> None:
+    """Clear command history."""
+    run_history_clear(
+        alias=alias,
+        yes=yes,
+        get_history_service=container.get_history_service,
+        get_console=container.get_console,
+    )
+
+
+@app.command("last")
+@cli_guard
+def rerun_last() -> None:
+    """Re-executes the last command run."""
+    run_rerun_last(
+        get_run_service=container.get_run_service,
+        get_history_service=container.get_history_service,
+        get_console=container.get_console,
+    )

cmdbox/cli/commands/init.py

@@ -0,0 +1,54 @@
+import logging
+from typing import Annotated
+
+import typer
+
+from cmdbox import container
+from cmdbox.cli.common.errors import make_cli_guard
+from cmdbox.cli.handlers.init_handler import run_detect_shell, run_init_command
+
+app = typer.Typer(no_args_is_help=False)
+
+cli_guard = make_cli_guard(container.get_console)
+
+log = logging.getLogger(__name__)
+
+
+@app.command()
+@cli_guard
+def init(
+    shell: Annotated[
+        str,
+        typer.Argument(
+            help="The shell to initialize. bash, zsh, fish, powershell, or cmd"
+        ),
+    ] = None,
+    install: Annotated[
+        bool,
+        typer.Option(
+            "--install",
+            "-i",
+            is_flag=True,
+            help="Install into the shell profile where applicable. If False, the profile modification will be"
+            "printed for you to make the profile changes manually.  This may not work on all profiles.",
+        ),
+    ] = False,
+    path: Annotated[
+        str, typer.Option("--path", "-p", help="The path to the shell profile.")
+    ] = None,
+) -> None:
+    """
+    Initialize CmdBox for a shell environment.
+    """
+    log.debug("init.init called. shell=%s, install=%s", shell, install)
+    run_init_command(
+        shell=shell, install=install, path=path, get_console=container.get_console
+    )
+
+
+@app.command(name="shell", hidden=True)
+@cli_guard
+def detect_shell() -> None:
+    """Detects and prints the current shell being used."""
+    log.debug("init.shell called.")
+    run_detect_shell(get_console=container.get_console)

cmdbox/cli/commands/settings.py

@@ -0,0 +1,62 @@
+import logging
+from typing import Annotated
+
+import typer
+
+from cmdbox import container
+from cmdbox.cli.common.errors import make_cli_guard
+from cmdbox.cli.handlers import settings_handler
+
+app = typer.Typer(no_args_is_help=True)
+
+cli_guard = make_cli_guard(container.get_console)
+
+log = logging.getLogger(__name__)
+
+
+@app.command("edit")
+@cli_guard
+def edit(
+    external: Annotated[
+        bool,
+        typer.Option(
+            "--external",
+            "-e",
+            help="Edit settings file directly in terminal.",
+        ),
+    ] = False,
+) -> None:
+    """
+    Edits the settings file. If the `--external` flag is used, the settings file will be
+    opened in the default text editor. Otherwise, the settings will be edited interactively
+    in the terminal.
+    """
+    log.debug("settings.edit called. external=%s", external)
+    settings_handler.run_edit_settings(
+        external,
+        get_settings_service=container.get_settings_service,
+        get_console=container.get_console,
+    )
+
+
+@app.command("show")
+@cli_guard
+def show(
+    fields: Annotated[
+        str | None,
+        typer.Option(
+            "--fields",
+            "-f",
+            help="List of fields to show separated by comma. If not provided, all fields will be shown.",
+        ),
+    ] = None,
+) -> None:
+    """
+    Outputs the current settings in a stylized table view.
+    """
+    log.debug("settings.show called. fields=%s", fields)
+    settings_handler.run_show_settings(
+        fields=fields,
+        get_settings_service=container.get_settings_service,
+        get_console=container.get_console,
+    )