cmdbox-cli 1.0.0__py3-none-any.whl

cmdbox/cli/handlers/init_handler.py

@@ -0,0 +1,127 @@
+import shutil
+from pathlib import Path
+from typing import Callable
+
+import typer
+
+from cmdbox.cli.ui.console import ConsoleUI
+from cmdbox.cli.ui.presenters.init_presenter import (
+    render_install_instructions,
+    render_install_success,
+    render_shell_output,
+)
+from cmdbox.init.detect import detect_shell
+from cmdbox.init.io import load_integration_text, upsert_marked_block
+from cmdbox.init.specs import SHELLS
+from cmdbox.logging_setup.log_decorators import log_action
+
+
+@log_action(__name__, "run_init_command")
+def run_init_command(
+    *,
+    shell: str = None,
+    install: bool = False,
+    path: str = None,
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    """
+    Executes the initialization command for shell integration, handling snippet output,
+    installation, and providing specific configurations based on the operating system shell.
+
+    This function manages different installation modes (e.g., updating profile files,
+    writing integration files, or providing wrapper hints) and facilitates smooth integration
+    of the application with the user's shell environment.
+
+    Args:
+        shell (str): The shell name provided for integration. Must match one of the expected keys
+            in the `SHELLS` dictionary (case-insensitive).
+        install (bool): Specifies whether to install the integration snippet to the shell's
+            configuration file or output the snippet to stdout. Defaults to `False`.
+        path (str, optional): A custom path to the file to which the integration snippet
+            will be written when `install` is `True`. If not provided, defaults to the
+            path determined by the shell specification.
+        get_console (Callable[[], ConsoleUI]): A callable returning an instance of `ConsoleUI`
+            to handle console output and user feedback.
+
+    Raises:
+        typer.BadParameter: If an invalid shell name is provided that does not exist in the
+            `SHELLS` dictionary.
+    """
+    console = get_console()
+
+    if not shell:
+        shell = detect_shell()
+
+    shell_key = shell.lower()
+    if shell_key not in SHELLS:
+        raise typer.BadParameter(f"Invalid shell: {shell}")
+
+    spec = SHELLS[shell_key]
+    snippet = load_integration_text(spec.filename)
+
+    if not install:
+        title = f"Install instructions for {spec.name}"
+        console.print(
+            render_install_instructions(
+                snippet, shell=shell, title=title, include_help_text=shell != "cmd"
+            )
+        )
+        return
+
+    target = (
+        Path(path)
+        if path
+        else (spec.default_path_fn() if spec.default_path_fn else None)
+    )
+
+    if spec.install_mode == "profile_block":
+        if target is None:
+            raise typer.BadParameter(
+                f"No default install path available for shell: {spec.name}."
+            )
+        upsert_marked_block(target, snippet)
+        console.print(render_install_success())
+        return
+
+    if spec.install_mode == "write_file":
+        if target is None:
+            raise typer.BadParameter(
+                f"No default install path available for shell: {spec.name}."
+            )
+
+        if target.exists():
+            backup = target.with_suffix(target.suffix + ".bak")
+            shutil.copy2(target, backup)
+
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(snippet, encoding="utf-8")
+        console.print(render_install_success())
+        return
+
+    if spec.install_mode == "wrapper_hint":
+        title = "Unable to install snippet for cmd shell"
+        console.print(
+            render_install_instructions(
+                snippet, shell="cmd", title=title, include_help_text=False
+            )
+        )
+        return
+
+
+@log_action(__name__, "run_detect_shell")
+def run_detect_shell(*, get_console: Callable[[], ConsoleUI]) -> None:
+    """
+    Detects the current shell being used and prints it to the console.
+
+    This function retrieves a `ConsoleUI` object using the provided `get_console`
+    callable. It then detects the current shell and sends a message with the name
+    of the detected shell to be displayed on the console.
+
+    Args:
+        get_console (Callable[[], ConsoleUI]): A callable that, when invoked,
+            returns an instance of a `ConsoleUI` object used for displaying the
+            detected shell information.
+    """
+    console = get_console()
+    shell = detect_shell()
+    console.print(render_shell_output(shell))

cmdbox/cli/handlers/run_handler.py

@@ -0,0 +1,178 @@
+import logging
+from typing import Callable
+from dataclasses import dataclass
+
+import typer
+
+from cmdbox.cli.prompts.prompts import prompt_for_missing_var
+from cmdbox.cli.ui.console import ConsoleUI
+from cmdbox.cli.ui.presenters.result_presenter import (
+    render_execution_result,
+    render_preview_result,
+)
+from cmdbox.runtime.executor import RunContext
+from cmdbox.services.run_service import RunService
+from cmdbox.settings.models import Settings
+from cmdbox.logging_setup.log_decorators import log_action
+
+log = logging.getLogger(__name__)
+
+
+@dataclass(frozen=False)
+class RawRunContext:
+    """
+    This dataclass is effectively the same as the actual RunContext
+    except that it takes a different 'pre-parsed' version of the
+    env argument.  This class takes the argument in a format that
+    can be supplied by the user, which must then be parsed into a
+    format that can be used by the RunContext.
+    """
+
+    cwd: str | None = None
+    env: list[str] | str | None = None
+    capture: bool = False
+    shell: str | None = None
+    timeout: int | None = None
+    emit: bool = False
+    verbose: bool = False
+
+
+@log_action(__name__, "run_run_command")
+def run_run_command(
+    *,
+    alias: str,
+    runtime_vars: dict[str, str] | None = None,
+    run_ctx: RawRunContext | None = None,
+    get_run_service: Callable[[], RunService],
+    get_settings: Callable[[], Settings],
+    get_console: Callable[[], ConsoleUI],
+):
+    if run_ctx and run_ctx.verbose is None:
+        settings = get_settings()
+        run_ctx.verbose = settings.execution_settings.default_verbose
+
+    run_service = get_run_service()
+
+    missing = run_service.collect_missing_vars(alias, runtime_vars=runtime_vars)
+    if missing:
+        for var_name in missing:
+            value = prompt_for_missing_var(var_name)
+            runtime_vars[var_name] = value
+
+    run_ctx = get_run_ctx(run_ctx) if run_ctx else RunContext()
+    ex_result = run_service.run(alias, ctx=run_ctx, runtime_vars=runtime_vars)
+    if run_ctx.verbose and not run_ctx.emit:
+        console = get_console()
+        console.print(render_execution_result(ex_result))
+
+
+@log_action(__name__, "run_preview_command")
+def run_preview_command(
+    *,
+    alias: str,
+    runtime_vars: dict[str, str] | None = None,
+    run_ctx: RawRunContext | None = None,
+    get_run_service: Callable[[], RunService],
+    get_settings: Callable[[], Settings],
+    get_console: Callable[[], ConsoleUI],
+):
+    if run_ctx and run_ctx.verbose is None:
+        settings = get_settings()
+        run_ctx.verbose = settings.execution_settings.default_verbose
+
+    run_service = get_run_service()
+
+    missing = run_service.collect_missing_vars(alias, runtime_vars=runtime_vars)
+    if missing:
+        for var_name in missing:
+            value = prompt_for_missing_var(var_name)
+            runtime_vars[var_name] = value
+
+    run_ctx = get_run_ctx(run_ctx) if run_ctx else RunContext()
+    prev_result, effective_ctx = run_service.preview(
+        alias, runtime_vars=runtime_vars, ctx=run_ctx
+    )
+    rendered_result = render_preview_result(prev_result, ctx=effective_ctx)
+    console = get_console()
+    console.print(rendered_result)
+
+
+def get_run_ctx(raw_run_ctx: RawRunContext | None) -> RunContext:
+    """
+    Creates and returns a `RunContext` object based on the provided `raw_run_ctx`.
+
+    If the `raw_run_ctx` is not provided (i.e., is None), a default `RunContext` is
+    created and returned. If `raw_run_ctx` is provided, its properties are used to
+    initialize the `RunContext`, and its environment is parsed before being passed
+    to the new context.
+
+    Args:
+        raw_run_ctx: An instance of `RawRunContext` or None. If provided, it must
+            contain context information such as current working directory, shell
+            configuration, and environment variables.
+
+    Returns:
+        RunContext: A `RunContext` object constructed using the provided
+        `raw_run_ctx` or with default values if no `raw_run_ctx` is provided.
+    """
+    if raw_run_ctx is None:
+        return RunContext()
+
+    env = parse_env(raw_run_ctx.env)
+    return RunContext(
+        cwd=raw_run_ctx.cwd,
+        env=env,
+        capture=raw_run_ctx.capture,
+        shell=raw_run_ctx.shell,
+        timeout=raw_run_ctx.timeout,
+        emit=raw_run_ctx.emit,
+        verbose=raw_run_ctx.verbose,
+    )
+
+
+def parse_env(env: list[str] | str | None) -> dict[str, str] | None:
+    """
+    Parses a list, string, or None value into a dictionary where each key-value pair
+    represents an environment variable, with the key and value extracted from the
+    input format. If the input is None, returns None.
+
+    Args:
+        env (list[str] | str | None): A list of strings, a comma-separated string,
+            or None, where each string is in the format "key=value".
+
+    Returns:
+        dict[str, str] | None: A dictionary containing the parsed environment
+            variables as key-value pairs, or None if the input is None.
+
+    Raises:
+        typer.BadParameter: If an entry in the input does not follow the
+            "key=value" format.
+    """
+    if env is None:
+        return None
+
+    ret = {}
+
+    if isinstance(env, str):
+        env = env.split(",")
+
+    def split_pair(pair: str) -> tuple[str, str]:
+        if "=" not in pair:
+            log.error(f"Invalid environment variable format: {pair}")
+            raise typer.BadParameter(
+                "Invalid environment variable format. Each env must be in the format of key=value."
+            )
+        k, v = pair.split("=", maxsplit=1)
+        log.debug(f"Parsed env: {k}={v}")
+        return k, v
+
+    for pair in env:
+        if "," in pair:
+            for k, v in map(split_pair, pair.split(",")):
+                ret[k] = v
+        else:
+            k, v = split_pair(pair)
+            ret[k] = v
+
+    log.debug(f"Parsed env: {ret}")
+    return ret

cmdbox/cli/handlers/settings_handler.py

@@ -0,0 +1,59 @@
+import logging
+from typing import Callable
+
+import typer
+
+from cmdbox.cli.ui.console import ConsoleUI
+from cmdbox.cli.ui.editor import edit_text_fullscreen, EditCanceled, edit_text_in_editor
+from cmdbox.cli.ui.presenters.settings_presenter import render_settings_show
+from cmdbox.logging_setup.log_decorators import log_action
+from cmdbox.settings.settings_service import SettingsService
+
+log = logging.getLogger(__name__)
+
+
+@log_action(__name__, "run_edit_settings")
+def run_edit_settings(
+    external: bool = True,
+    *,
+    get_settings_service: Callable[[], SettingsService],
+    get_console: Callable[[], ConsoleUI],
+):
+    settings_service = get_settings_service()
+    console = get_console()
+
+    def editor_fn(initial_text: str) -> str:
+        if external:
+            return edit_text_in_editor(
+                initial_text, suffix=".toml", title_hint="CmdBox Settings"
+            )
+        else:
+            return edit_text_fullscreen(initial_text, title="Edit Settings")
+
+    try:
+        settings_service.edit(editor_fn)
+        console.success("Settings saved.")
+    except EditCanceled:
+        console.info("Settings not saved.")
+        raise typer.Exit(code=0)
+    except Exception as exc:
+        log.error("Error saving settings.", exc_info=True)
+        console.error(f"Error saving settings: {exc}")
+        raise typer.Exit(code=1)
+
+
+@log_action(__name__, "run_show_settings")
+def run_show_settings(
+    fields: str | None = None,
+    *,
+    get_settings_service: Callable[[], SettingsService],
+    get_console: Callable[[], ConsoleUI],
+):
+    parsed_fields = fields.split(",") if fields else None
+
+    settings_service = get_settings_service()
+    console = get_console()
+
+    settings = settings_service.get()
+    output = render_settings_show(settings, parsed_fields)
+    console.print(output)

cmdbox/cli/handlers/tag_handlers.py

@@ -0,0 +1,220 @@
+from dataclasses import dataclass
+from typing import Optional, Callable, Any, Sequence, Dict
+
+import typer
+
+from cmdbox.cli.common.update_fields import (
+    merge_fields,
+    parse_set_pairs,
+    filter_allowed,
+)
+from cmdbox.cli.prompts.prompts import (
+    prompt_for_name,
+    prompt_for_description,
+)
+from cmdbox.cli.ui.presenters.tag_presenter import (
+    render_tag_created,
+    render_tag,
+    render_tag_list,
+    render_tag_updated,
+    render_tag_deleted,
+)
+from cmdbox.cli.prompts.validators import TagNameValidator
+from cmdbox.cli.ui.console import ConsoleUI
+from cmdbox.services.field_selection import FieldSelectionResolver
+from cmdbox.services.tag_services import TagServices
+from cmdbox.settings.models import Settings
+from cmdbox.logging_setup.log_decorators import log_action
+
+
+@dataclass(frozen=True)
+class AddTagArgs:
+    name: Optional[str]
+    description: Optional[str]
+    interactive: bool = False
+
+
+@log_action(__name__, "run_add_tag")
+def run_add_tag(
+    *,
+    args: AddTagArgs,
+    get_tag_services: Callable[[], TagServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    name = args.name
+    description = args.description
+
+    if args.interactive or name is None:
+        name = prompt_for_name(TagNameValidator())
+
+    if args.interactive or description is None:
+        description = prompt_for_description()
+
+    tag_service = get_tag_services()
+    tag = tag_service.create_tag(name=name, description=description)
+    console = get_console()
+    console.print(render_tag_created(tag))
+
+
+@log_action(__name__, "run_get_tag")
+def run_get_tag(
+    *,
+    name: str,
+    get_tag_services: Callable[[], TagServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    console = get_console()
+    tag_service = get_tag_services()
+    tag = tag_service.get_tag(name)
+    console.print(render_tag(tag))
+
+
+@log_action(__name__, "run_update_tag")
+def run_update_tag(
+    *,
+    name: str,
+    description: Optional[str],
+    new_name: Optional[str],
+    set_pairs: Optional[Sequence[str]],
+    edit_mode: bool,
+    edit_fields: Optional[str],
+    get_tag_services: Callable[[], TagServices],
+    get_settings: Callable[[], Settings],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    allowed = {"name", "description"}
+    fields: Dict[str, Any] = {}
+
+    tag_service = get_tag_services()
+    tag = tag_service.get_tag(name)
+    console = get_console()
+
+    if edit_mode:
+        if any([description, new_name, set_pairs]):
+            raise typer.BadParameter(
+                "--edit cannot be combined with field options or --set."
+            )
+
+        updated_fields: dict[str, Any] = {}
+        if edit_fields:
+            edit_fields = [x.strip() for x in edit_fields.split(",")]
+
+        field_aliases = get_settings().field_aliases.alias_mapping
+
+        def check_field_aliases(field: str) -> bool:
+            return (
+                edit_fields is None
+                or field in edit_fields
+                or any(x in edit_fields for x in field_aliases.get(field, []))
+            )
+
+        if check_field_aliases("name"):
+            updated_fields["name"] = prompt_for_name(
+                TagNameValidator(), default=tag.name
+            )
+        if check_field_aliases("description"):
+            updated_fields["description"] = prompt_for_description(
+                default=tag.description
+            )
+
+        fields = updated_fields
+
+    else:
+        if description is not None:
+            fields["description"] = description
+        if new_name is not None:
+            fields["name"] = new_name
+
+        fields = merge_fields(fields, parse_set_pairs(set_pairs))
+        fields = filter_allowed(fields, allowed)
+
+        if not fields:
+            raise typer.BadParameter("No fields specified to update.")
+
+    current = {
+        "name": tag.name,
+        "description": tag.description,
+    }
+    fields = {key: value for key, value in fields.items() if current.get(key) != value}
+
+    if not fields:
+        console.info("No changes detected.")
+        return
+
+    tag_service.update_tag(name, **fields)
+
+    updated_tag = tag_service.get_tag_by_id(tag.id)
+    console.print(render_tag_updated(updated_tag))
+
+
+@log_action(__name__, "run_list_tags")
+def run_list_tags(
+    *,
+    limit: int,
+    order_by: str,
+    fields: list[str] | None = None,
+    get_tag_services: Callable[[], TagServices],
+    get_settings: Callable[[], Settings],
+    get_console: Callable[[], ConsoleUI],
+    get_display_field_resolver: Callable[[], FieldSelectionResolver],
+) -> None:
+    console = get_console()
+    tag_service = get_tag_services()
+    tags = tag_service.list_tags(limit=limit, order_by=order_by)
+
+    settings = get_settings()
+    fields = get_display_field_resolver().resolve(
+        fields,
+        default_fields=settings.default_fields.tag_output,
+        aliases=settings.field_aliases.alias_map,
+    )
+
+    console.print(render_tag_list(tags, title="Tags", fields=fields))
+
+
+@log_action(__name__, "run_search_tags")
+def run_search_tags(
+    *,
+    term: str,
+    limit: int,
+    search_fields: list[str] | None = None,
+    fields: list[str] | None = None,
+    get_tag_services: Callable[[], TagServices],
+    get_settings: Callable[[], Settings],
+    get_console: Callable[[], ConsoleUI],
+    get_display_field_resolver: Callable[[], FieldSelectionResolver],
+    get_search_field_resolver: Callable[[], FieldSelectionResolver],
+) -> None:
+    console = get_console()
+    tag_service = get_tag_services()
+
+    settings = get_settings()
+    output_fields = get_display_field_resolver().resolve(
+        fields,
+        default_fields=settings.default_fields.tag_output,
+        aliases=settings.field_aliases.alias_map,
+    )
+    search_fields = get_search_field_resolver().resolve(
+        search_fields,
+        default_fields=settings.default_fields.tag_search,
+        aliases=settings.field_aliases.alias_map,
+    )
+
+    tags = tag_service.search(term, limit=limit, fields=search_fields)
+    console.print(render_tag_list(tags, title="Search Results", fields=output_fields))
+
+
+@log_action(__name__, "run_delete_tag")
+def run_delete_tag(
+    *,
+    name: str,
+    get_tag_services: Callable[[], TagServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    console = get_console()
+    tag_service = get_tag_services()
+    tag = tag_service.get_tag(name)
+    if tag_service.delete_tag(name):
+        console.print(render_tag_deleted(tag))
+    else:
+        console.error(f"Failed to delete tag '{name}'.")