cmdbox-cli 1.0.0__py3-none-any.whl

cmdbox/cli/common/update_fields.py

@@ -0,0 +1,88 @@
+from typing import Any, Optional, Iterable, Dict
+import typer
+
+
+def parse_set_pairs(pairs: Optional[list[str]]) -> Dict[str, str]:
+    """
+    Parses a list of key-value string pairs and converts them into a dictionary.
+
+    This function takes a list of strings formatted as "key=value", validates their structure,
+    and converts them into a dictionary where the keys and values correspond to the
+    parsed components of the strings. Invalid pairs result in an error being raised.
+
+    Args:
+        pairs (Optional[list[str]]): A list of strings where each string is formatted
+            as "key=value". If the list is empty or None, an empty dictionary is returned.
+
+    Returns:
+        Dict[str, str]: A dictionary where the keys and values correspond to the parsed
+            key-value pairs from the input list.
+
+    Raises:
+        typer.BadParameter: If any string in the list does not contain an "=" character,
+            or if the key part is empty after splitting.
+    """
+    out: Dict[str, str] = {}
+    if not pairs:
+        return out
+    for item in pairs:
+        if "=" not in item:
+            raise typer.BadParameter(f"Invalid --set value '{item}'. Use key=value.")
+        k, v = item.split("=", 1)
+        k = k.strip()
+        if not k:
+            raise typer.BadParameter(
+                f"Invalid --set value '{item}'. Key cannot be empty."
+            )
+        out[k] = v
+    return out
+
+
+def merge_fields(base: Dict[str, Any], extra: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Merges two dictionaries and ensures there are no overlapping keys. If overlapping keys
+    are detected, an error is raised with a detailed message indicating the conflicts.
+
+    Args:
+        base (Dict[str, Any]): The base dictionary to merge into.
+        extra (Dict[str, Any]): The additional dictionary containing keys and values to
+            merge into the base dictionary.
+
+    Returns:
+        Dict[str, Any]: A new dictionary with the combined keys and values from the
+        `base` and `extra` dictionaries.
+
+    Raises:
+        typer.BadParameter: If the `base` and `extra` dictionaries have overlapping keys.
+    """
+    conflicts = set(base).intersection(extra)
+    if conflicts:
+        keys = ", ".join(sorted(conflicts))
+        raise typer.BadParameter(f"Field(s) specified multiple ways: {keys}")
+    merged = dict(base)
+    merged.update(extra)
+    return merged
+
+
+def filter_allowed(fields: Dict[str, Any], allowed: Iterable[str]) -> Dict[str, Any]:
+    """
+    Filters a dictionary to retain only allowed keys and raises an error if unknown keys are
+    present in the dictionary.
+
+    Args:
+        fields (Dict[str, Any]): A dictionary containing the fields to filter.
+        allowed (Iterable[str]): An iterable of allowed keys.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing only the fields with keys found in the allowed
+        set.
+
+    Raises:
+        typer.BadParameter: If the dictionary contains keys not found in the allowed set.
+    """
+    allowed_set = set(allowed)
+    unknown = [k for k in fields.keys() if k not in allowed_set]
+    if unknown:
+        keys = ", ".join(sorted(unknown))
+        raise typer.BadParameter(f"Unknown field(s) for --set: {keys}")
+    return fields

cmdbox/cli/completions/commands.py

@@ -0,0 +1,26 @@
+def complete_command_aliases(incomplete: str) -> list[str]:
+    """
+    Completes a list of command aliases based on the provided partial string.
+
+    This function provides completion suggestions for command aliases. If the
+    input string is empty, it returns a default list of command aliases ordered
+    by their last updated timestamps. Otherwise, it performs a search based on
+    the provided input string to retrieve relevant command aliases.
+
+    Args:
+        incomplete (str): The partial command alias string to search for. If an
+            empty string is provided, the function returns a list of the most
+            updated command aliases.
+
+    Returns:
+        list[str]: A list of command aliases that match the input string or
+        the most recently updated aliases if the input is empty.
+    """
+    from cmdbox.container import get_command_services
+
+    svc = get_command_services()
+    if incomplete == "":
+        cmds = svc.list_commands(order_by="last_updated", limit=20)
+    else:
+        cmds = svc.search(incomplete, fields="alias", limit=20)
+    return [x.alias for x in cmds]

cmdbox/cli/completions/fields.py

@@ -0,0 +1,31 @@
+from cmdbox.models import Command, Variable, Tag
+
+
+def command_field_options(incomplete: str) -> list[str]:
+    fields = Command._meta.sorted_field_names
+    return [field for field in fields if field.startswith(incomplete)]
+
+
+def command_editable_field_options(incomplete: str) -> list[str]:
+    fields = ["alias", "template", "description"]
+    return [field for field in fields if field.startswith(incomplete)]
+
+
+def variable_field_options(incomplete: str) -> list[str]:
+    fields = Variable._meta.sorted_field_names
+    return [field for field in fields if field.startswith(incomplete)]
+
+
+def variable_editable_field_options(incomplete: str) -> list[str]:
+    fields = ["name", "value"]
+    return [field for field in fields if field.startswith(incomplete)]
+
+
+def tag_field_options(incomplete: str) -> list[str]:
+    fields = Tag._meta.sorted_field_names
+    return [field for field in fields if field.startswith(incomplete)]
+
+
+def tag_editable_field_options(incomplete: str) -> list[str]:
+    fields = ["name", "description"]
+    return [field for field in fields if field.startswith(incomplete)]

cmdbox/cli/completions/tags.py

@@ -0,0 +1,24 @@
+def complete_tag_names(incomplete: str) -> list[str]:
+    """
+    Completes a list of tag names based on the provided partial string.
+
+    This function provides completion suggestions for tag names.  If the input string is empty,
+    it returns a default list of tag names ordered by their last updated timestamps. Otherwise,
+    it performs a search for tags that match or are derived from the given incomplete string.
+
+    Args:
+        incomplete (str): The partial tag string to search for. If an empty string is provided,
+            the function returns a list of the most recently updated tags.
+
+    Returns:
+        list[str]: A list of tag names matching or related to the given incomplete string.
+    """
+    from cmdbox.container import get_tag_services
+
+    svc = get_tag_services()
+
+    if incomplete == "":
+        tags = svc.list_tags(order_by="last_updated", limit=20)
+    else:
+        tags = svc.search(incomplete, fields="name", limit=20)
+    return [tag.name for tag in tags]

cmdbox/cli/completions/variables.py

@@ -0,0 +1,26 @@
+def complete_variable_names(incomplete: str) -> list[str]:
+    """
+    Completes a list of variable names based on the provided partial string.
+
+    This function provides completion suggestions for variable names. If the
+    input string is empty, it returns a default list of variable names ordered
+    by their last updated timestamps. Otherwise, it performs a search based on
+    the provided input string to retrieve relevant variable names.
+
+    Args:
+        incomplete (str): The partial variable name string to search for. If an
+            empty string is provided, the function returns a list of the most
+            updated variable names.
+
+    Returns:
+        list[str]: A list of variable names that match the input string or
+        the most recently updated aliases if the input is empty.
+    """
+    from cmdbox.container import get_variable_services
+
+    svc = get_variable_services()
+    if incomplete == "":
+        variables = svc.list_variables(order_by="last_updated", limit=20)
+    else:
+        variables = svc.search(incomplete, fields="name", limit=20)
+    return [var.name for var in variables]

cmdbox/cli/handlers/command_handlers.py

@@ -0,0 +1,357 @@
+import json
+from dataclasses import dataclass
+from typing import Optional, Callable, Any, Sequence
+
+import typer
+
+from cmdbox.cli.common.update_fields import (
+    merge_fields,
+    parse_set_pairs,
+    filter_allowed,
+)
+from cmdbox.cli.handlers.common_handlers import get_tags_interactive
+from cmdbox.cli.prompts.prompts import (
+    prompt_for_alias,
+    prompt_for_template,
+    prompt_for_description,
+    prompt_for_cwd,
+    prompt_for_shell,
+    prompt_for_timeout,
+)
+
+from cmdbox.cli.prompts.validators import AliasValidator, TemplateValidator
+from cmdbox.cli.ui.console import ConsoleUI
+from cmdbox.cli.ui.presenters.command_presenter import (
+    render_command,
+    render_command_list,
+    render_command_created,
+    render_command_updated,
+    render_command_deleted,
+)
+from cmdbox.cli.ui.presenters.result_presenter import (
+    render_tag_attach_result,
+    render_tag_detach_result,
+)
+from cmdbox.services.command_services import CommandServices
+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 AddCommandArgs:
+    alias: Optional[str]
+    template: Optional[str]
+    description: Optional[str]
+    tags: Optional[list[str]]
+    cwd: Optional[str] = None
+    shell: Optional[str] = None
+    env: Optional[list[str]] = None
+    timeout: Optional[int] = None
+    interactive: bool = False
+
+
+@log_action(__name__, "run_add_command")
+def run_add_command(
+    *,
+    args: AddCommandArgs,
+    get_cmd_services: Callable[[], CommandServices],
+    get_tag_services: Callable[[], TagServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    alias = args.alias
+    template = args.template
+    description = args.description
+    tags = args.tags
+
+    if args.interactive or args.alias is None:
+        alias = prompt_for_alias(AliasValidator())
+
+    if args.interactive or args.template is None:
+        template = prompt_for_template(TemplateValidator())
+
+    if args.interactive or args.description is None:
+        description = prompt_for_description()
+
+    if args.interactive or args.tags is None:
+        tags = get_tags_interactive(get_tag_services())
+    if not tags:
+        tags = None
+
+    env = parse_env_pairs(args.env)
+
+    cmd_service = get_cmd_services()
+    cmd = cmd_service.create_command(
+        alias=alias,
+        template=template,
+        description=description,
+        tags=tags,
+        cwd=args.cwd,
+        shell=args.shell,
+        env=env,
+        timeout=args.timeout,
+    )
+    console = get_console()
+    console.print(render_command_created(cmd))
+
+
+@log_action(__name__, "run_get_command")
+def run_get_command(
+    *,
+    alias: str,
+    get_cmd_services: Callable[[], CommandServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    console = get_console()
+    cmd_service = get_cmd_services()
+    cmd = cmd_service.get_command(alias)
+    rendered_cmd = render_command(cmd)
+    console.print(rendered_cmd)
+
+
+@log_action(__name__, "run_update_command")
+def run_update_command(
+    *,
+    alias: str,
+    template: Optional[str],
+    description: Optional[str],
+    new_alias: Optional[str],
+    cwd: Optional[str],
+    shell: Optional[str],
+    env: Optional[list[str]],
+    timeout: Optional[int],
+    set_pairs: Optional[Sequence[str]],
+    edit_mode: bool,
+    edit_fields: Optional[str],
+    get_cmd_services: Callable[[], CommandServices],
+    get_settings: Callable[[], Settings],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    allowed = {"alias", "template", "description", "cwd", "shell", "env", "timeout"}
+    fields: dict[str, Any] = {}
+
+    cmd_service = get_cmd_services()
+    cmd = cmd_service.get_command(alias)
+    console = get_console()
+
+    if edit_mode:
+        if any([template, description, new_alias, cwd, shell, env, timeout, 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_alias(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_alias("alias"):
+            updated_fields["alias"] = prompt_for_alias(
+                AliasValidator(), default=cmd.alias
+            )
+        if check_field_alias("template"):
+            updated_fields["template"] = prompt_for_template(
+                TemplateValidator(), default=cmd.template
+            )
+        if check_field_alias("description"):
+            updated_fields["description"] = prompt_for_description(
+                default=cmd.description
+            )
+        if check_field_alias("cwd"):
+            updated_fields["cwd"] = prompt_for_cwd(default=cmd.cwd or "")
+        if check_field_alias("shell"):
+            updated_fields["shell"] = prompt_for_shell(default=cmd.shell or "") or None
+        if check_field_alias("timeout"):
+            updated_fields["timeout"] = prompt_for_timeout(
+                default=str(cmd.timeout) if cmd.timeout else ""
+            )
+
+        fields = updated_fields
+
+    else:
+        if template is not None:
+            fields["template"] = template
+        if description is not None:
+            fields["description"] = description
+        if new_alias is not None:
+            fields["alias"] = new_alias
+        if cwd is not None:
+            fields["cwd"] = cwd
+        if shell is not None:
+            fields["shell"] = shell
+        if env is not None:
+            fields["env"] = parse_env_pairs(env)
+        if timeout is not None:
+            fields["timeout"] = timeout
+
+        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.")
+
+    stored_env = json.loads(cmd.env) if cmd.env else None
+    current = {
+        "alias": cmd.alias,
+        "template": cmd.template,
+        "description": cmd.description,
+        "cwd": cmd.cwd,
+        "shell": cmd.shell,
+        "env": stored_env,
+        "timeout": cmd.timeout,
+    }
+    fields = {key: value for key, value in fields.items() if current.get(key) != value}
+
+    if not fields:
+        console.info("No changes detected.")
+        return
+
+    cmd_service.update_command(alias, **fields)
+
+    updated_cmd = cmd_service.get_command_by_id(cmd.id)
+    console.print(render_command_updated(updated_cmd))
+
+
+@log_action(__name__, "run_list_command")
+def run_list_command(
+    *,
+    limit: int,
+    order: str,
+    tags: list[str],
+    fields: list[str] | None = None,
+    get_cmd_services: Callable[[], CommandServices],
+    get_settings: Callable[[], Settings],
+    get_console: Callable[[], ConsoleUI],
+    get_display_field_resolver: Callable[[], FieldSelectionResolver],
+) -> None:
+    console = get_console()
+    cmd_service = get_cmd_services()
+
+    settings = get_settings()
+    resolved_fields = get_display_field_resolver().resolve(
+        fields,
+        default_fields=settings.default_fields.command_output,
+        aliases=settings.field_aliases.alias_map,
+    )
+
+    cmds = cmd_service.list_commands(limit=limit, order_by=order, tags=tags)
+    rendered_cmd_list = render_command_list(
+        cmds, title="Commands", fields=resolved_fields
+    )
+    console.print(rendered_cmd_list)
+
+
+@log_action(__name__, "run_search_command")
+def run_search_command(
+    *,
+    term: str,
+    limit: int,
+    search_fields: list[str] | None = None,
+    fields: list[str] | None = None,
+    get_cmd_services: Callable[[], CommandServices],
+    get_settings: Callable[[], Settings],
+    get_console: Callable[[], ConsoleUI],
+    get_display_field_resolver: Callable[[], FieldSelectionResolver],
+    get_search_field_resolver: Callable[[], FieldSelectionResolver],
+) -> None:
+    console = get_console()
+    cmd_service = get_cmd_services()
+
+    settings = get_settings()
+    output_fields = get_display_field_resolver().resolve(
+        fields,
+        default_fields=settings.default_fields.command_output,
+        aliases=settings.field_aliases.alias_map,
+    )
+    search_fields = get_search_field_resolver().resolve(
+        search_fields,
+        default_fields=settings.default_fields.command_search,
+        aliases=settings.field_aliases.alias_map,
+    )
+
+    cmds = cmd_service.search(term, limit=limit, fields=search_fields)
+    rendered_cmd_list = render_command_list(
+        cmds, title="Search Results", fields=output_fields
+    )
+    console.print(rendered_cmd_list)
+
+
+@log_action(__name__, "run_delete_command")
+def run_delete_command(
+    *,
+    alias: str,
+    get_cmd_services: Callable[[], CommandServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    console = get_console()
+    cmd_service = get_cmd_services()
+    cmd = cmd_service.get_command(alias)
+    if cmd_service.delete_command(alias):
+        console.print(render_command_deleted(cmd))
+    else:
+        console.error(f"Failed to delete command '{alias}'.")
+
+
+@log_action(__name__, "run_attach_tags")
+def run_attach_tags(
+    *,
+    alias: str | None = None,
+    tag_names: list[str] | None = None,
+    get_cmd_services: Callable[[], CommandServices],
+    get_tag_services: Callable[[], TagServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    if alias is None:
+        alias = prompt_for_alias(AliasValidator())
+    if tag_names is None:
+        tag_names = get_tags_interactive(get_tag_services())
+    cmd_service = get_cmd_services()
+    result = cmd_service.add_tags(alias=alias, tags=tag_names)
+    console = get_console()
+    console.print(render_tag_attach_result(result))
+
+
+@log_action(__name__, "run_detach_tags")
+def run_detach_tags(
+    *,
+    alias: str | None = None,
+    tag_names: list[str] | None = None,
+    get_cmd_services: Callable[[], CommandServices],
+    get_tag_services: Callable[[], TagServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    if alias is None:
+        alias = prompt_for_alias(AliasValidator())
+    if tag_names is None:
+        tag_names = get_tags_interactive(get_tag_services())
+    cmd_service = get_cmd_services()
+    result = cmd_service.remove_tags(alias=alias, tags=tag_names)
+    console = get_console()
+    console.print(render_tag_detach_result(result))
+
+
+def parse_env_pairs(env: list[str] | None) -> dict[str, str] | None:
+    if not env:
+        return None
+    result = {}
+    for pair in env:
+        if "=" not in pair:
+            raise typer.BadParameter(
+                f"Invalid env format '{pair}'. Expected key=value."
+            )
+        key, _, value = pair.partition("=")
+        if not key:
+            raise typer.BadParameter(
+                f"Invalid env format '{pair}'. Key cannot be empty."
+            )
+        result[key] = value
+    return result or None

cmdbox/cli/handlers/common_handlers.py

@@ -0,0 +1,15 @@
+from cmdbox.cli.prompts.completers import TagCompleter
+from cmdbox.cli.prompts.prompts import prompt_for_tags
+from cmdbox.cli.prompts.validators import TagNameValidator
+from cmdbox.services.tag_services import TagServices
+
+
+def get_tags_interactive(tag_services: TagServices) -> list[str] | None:
+    def get_tags(query: str) -> list[str]:
+        found_tags = tag_services.search(query, fields="name")
+        return [tag.name for tag in found_tags]
+
+    tag_completer = TagCompleter(get_tags)
+    validator = TagNameValidator()
+    tags = prompt_for_tags(tag_completer, validator)
+    return tags

cmdbox/cli/handlers/history_handlers.py

@@ -0,0 +1,94 @@
+from typing import Callable
+
+from cmdbox.cli.prompts.prompts import prompt_for_confirm
+from cmdbox.cli.ui.console import ConsoleUI
+from cmdbox.cli.ui.presenters.history_presenter import (
+    render_history_list,
+    render_history_entry,
+    render_history_cleared,
+)
+from cmdbox.logging_setup.log_decorators import log_action
+from cmdbox.runtime.executor import RunContext
+from cmdbox.services.history_service import HistoryService
+from cmdbox.services.run_service import RunService
+
+
+@log_action(__name__, "run_history_list")
+def run_history_list(
+    *,
+    alias: str | None,
+    limit: int,
+    get_history_service: Callable[[], HistoryService],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    service = get_history_service()
+    entries = service.get_recent(alias=alias, limit=limit)
+    console = get_console()
+    if not entries:
+        console.info("No history found")
+        return
+    console.print(render_history_list(entries))
+
+
+@log_action(__name__, "run_history_show")
+def run_history_show(
+    *,
+    ref: str,
+    get_history_service: Callable[[], HistoryService],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    service = get_history_service()
+    entry = service.get_by_ref(ref)
+    variables = service.get_variables(entry)
+    console = get_console()
+    console.print(render_history_entry(entry, variables))
+
+
+@log_action(__name__, "run_history_rerun")
+def run_history_rerun(
+    *,
+    ref: str,
+    get_history_service: Callable[[], HistoryService],
+    get_run_service: Callable[[], RunService],
+) -> None:
+    history_service = get_history_service()
+    entry = history_service.get_by_ref(ref)
+    variables = history_service.get_variables(entry)
+    run_service = get_run_service()
+    run_service.run(entry.alias, ctx=RunContext(), runtime_vars=variables)
+
+
+@log_action(__name__, "run_history_clear")
+def run_history_clear(
+    *,
+    alias: str | None,
+    yes: bool,
+    get_history_service: Callable[[], HistoryService],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    console = get_console()
+    if not yes:
+        scope = f" for '{alias}'" if alias else ""
+        if not prompt_for_confirm(f"Clear all history{scope}?"):
+            console.info("Aborted")
+            return
+    service = get_history_service()
+    count = service.clear(alias=alias)
+    console.print(render_history_cleared(count, alias))
+
+
+@log_action(__name__, "run_return_last")
+def run_rerun_last(
+    *,
+    get_history_service: Callable[[], HistoryService],
+    get_run_service: Callable[[], RunService],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    service = get_history_service()
+    entries = service.get_recent(limit=1)
+    if not entries:
+        get_console().info("No command history found")
+        return
+    entry = entries[0]
+    variables = service.get_variables(entry)
+    get_run_service().run(entry.alias, runtime_vars=variables)