cmdbox-cli 1.0.0__py3-none-any.whl

cmdbox/cli/handlers/variable_handlers.py

@@ -0,0 +1,272 @@
+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.handlers.common_handlers import get_tags_interactive
+from cmdbox.cli.prompts.prompts import (
+    prompt_for_name,
+    prompt_for_value,
+)
+from cmdbox.cli.prompts.validators import NameValidator
+from cmdbox.cli.ui.console import ConsoleUI
+from cmdbox.cli.ui.presenters.variable_presenter import (
+    render_variable_created,
+    render_variable,
+    render_variable_list,
+    render_variable_updated,
+    render_variable_deleted,
+)
+from cmdbox.cli.ui.presenters.result_presenter import (
+    render_tag_attach_result,
+    render_tag_detach_result,
+)
+from cmdbox.services.field_selection import FieldSelectionResolver
+from cmdbox.services.variable_services import VariableServices
+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 AddVariableArgs:
+    name: Optional[str]
+    value: Optional[str]
+    tags: Optional[list[str]]
+    interactive: bool = False
+
+
+@log_action(__name__, "run_add_variable")
+def run_add_variable(
+    *,
+    args: AddVariableArgs,
+    get_var_services: Callable[[], VariableServices],
+    get_tag_services: Callable[[], TagServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    name = args.name
+    value = args.value
+    tags = args.tags
+
+    if args.interactive or name is None:
+        name = prompt_for_name(NameValidator())
+
+    if args.interactive or value is None:
+        value = prompt_for_value()
+
+    if args.interactive or tags is None:
+        tags = get_tags_interactive(get_tag_services())
+    if not tags:
+        tags = None
+
+    var_service = get_var_services()
+    var = var_service.create_variable(name=name, value=value, tags=tags)
+    console = get_console()
+    console.print(render_variable_created(var))
+
+
+@log_action(__name__, "run_get_variable")
+def run_get_variable(
+    *,
+    name: str,
+    get_var_services: Callable[[], VariableServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    console = get_console()
+    var_service = get_var_services()
+    var = var_service.get_variable(name)
+    rendered_var = render_variable(var)
+    console.print(rendered_var)
+
+
+@log_action(__name__, "run_update_variable")
+def run_update_variable(
+    *,
+    name: str,
+    value: Optional[str],
+    new_name: Optional[str],
+    set_pairs: Optional[Sequence[str]],
+    edit_mode: bool,
+    edit_fields: Optional[str],
+    get_var_services: Callable[[], VariableServices],
+    get_settings: Callable[[], Settings],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    allowed = {"name", "value"}
+    fields: Dict[str, Any] = {}
+
+    var_service = get_var_services()
+    var = var_service.get_variable(name)
+    console = get_console()
+
+    if edit_mode:
+        if any([new_name, value, 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(NameValidator(), default=var.name)
+        if check_field_aliases("value"):
+            updated_fields["value"] = prompt_for_value(default=var.value)
+
+        fields = merge_fields(fields, updated_fields)
+
+    else:
+        if value is not None:
+            fields["value"] = value
+        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": var.name,
+        "value": var.value,
+    }
+    fields = {key: value for key, value in fields.items() if current.get(key) != value}
+
+    if not fields:
+        console.info("No changes detected.")
+        return
+
+    var_service.update_variable(name, **fields)
+
+    updated_var = var_service.get_variable_by_id(var.id)
+    console.print(render_variable_updated(updated_var))
+
+
+@log_action(__name__, "run_list_variables")
+def run_list_variables(
+    *,
+    limit: int,
+    order_by: str,
+    tags: list[str] | None,
+    fields: list[str] | None = None,
+    get_var_services: Callable[[], VariableServices],
+    get_settings: Callable[[], Settings],
+    get_console: Callable[[], ConsoleUI],
+    get_display_field_resolver: Callable[[], FieldSelectionResolver],
+) -> None:
+    console = get_console()
+    var_service = get_var_services()
+    vars_ = var_service.list_variables(limit=limit, order_by=order_by, tags=tags)
+
+    settings = get_settings()
+    fields = get_display_field_resolver().resolve(
+        fields,
+        default_fields=settings.default_fields.variable_output,
+        aliases=settings.field_aliases.alias_map,
+    )
+
+    console.print(render_variable_list(vars_, title="Variables", fields=fields))
+
+
+@log_action(__name__, "run_search_variables")
+def run_search_variables(
+    *,
+    term: str,
+    limit: int,
+    search_fields: list[str] | None = None,
+    fields: list[str] | None = None,
+    get_var_services: Callable[[], VariableServices],
+    get_settings: Callable[[], Settings],
+    get_console: Callable[[], ConsoleUI],
+    get_display_field_resolver: Callable[[], FieldSelectionResolver],
+    get_search_field_resolver: Callable[[], FieldSelectionResolver],
+) -> None:
+    console = get_console()
+    var_service = get_var_services()
+
+    settings = get_settings()
+    output_fields = get_display_field_resolver().resolve(
+        fields,
+        default_fields=settings.default_fields.variable_output,
+        aliases=settings.field_aliases.alias_map,
+    )
+    search_fields = get_search_field_resolver().resolve(
+        search_fields,
+        default_fields=settings.default_fields.variable_search,
+        aliases=settings.field_aliases.alias_map,
+    )
+
+    vars_ = var_service.search(term, limit=limit, fields=search_fields)
+    console.print(
+        render_variable_list(vars_, title="Search Results", fields=output_fields)
+    )
+
+
+@log_action(__name__, "run_delete_variable")
+def run_delete_variable(
+    *,
+    name: str,
+    get_var_services: Callable[[], VariableServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    console = get_console()
+    var_service = get_var_services()
+    var = var_service.get_variable(name)
+    if var_service.delete_variable(name):
+        console.print(render_variable_deleted(var))
+    else:
+        console.error(f"Failed to delete variable '{name}'.")
+
+
+@log_action(__name__, "run_attach_tags")
+def run_attach_tags(
+    *,
+    name: str | None = None,
+    tag_names: list[str] | None = None,
+    get_var_services: Callable[[], VariableServices],
+    get_tag_services: Callable[[], TagServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    if not name:
+        name = prompt_for_name(NameValidator())
+    if not tag_names:
+        tag_names = get_tags_interactive(get_tag_services())
+    var_service = get_var_services()
+    result = var_service.add_tags(name=name, tags=tag_names)
+    console = get_console()
+    console.print(render_tag_attach_result(result))
+
+
+@log_action(__name__, "run_detach_tags")
+def run_detach_tags(
+    *,
+    name: str | None = None,
+    tag_names: list[str] | None = None,
+    get_var_services: Callable[[], VariableServices],
+    get_tag_services: Callable[[], TagServices],
+    get_console: Callable[[], ConsoleUI],
+) -> None:
+    if not name:
+        name = prompt_for_name(NameValidator())
+    if not tag_names:
+        tag_names = get_tags_interactive(get_tag_services())
+    var_service = get_var_services()
+    result = var_service.remove_tags(name=name, tags=tag_names)
+    console = get_console()
+    console.print(render_tag_detach_result(result))

cmdbox/cli/prompts/completers.py

@@ -0,0 +1,161 @@
+from dataclasses import dataclass
+from typing import Callable, Sequence, Iterable, Tuple
+
+from prompt_toolkit.completion import Completer, Completion, CompleteEvent
+from prompt_toolkit.document import Document
+
+
+def _normalize_tag(s: str) -> str:
+    """
+    Normalizes a tag by stripping leading and trailing whitespace and converting the string to lowercase.
+
+    Args:
+        s (str): The string to be normalized.
+
+    Returns:
+        str: The normalized string.
+    """
+    return s.strip().lower()
+
+
+def _split_csv_like(text: str) -> Tuple[str, str, int]:
+    """
+    Split input into:
+        - prefix: Everything up to and including the last comma (and any following spaces)
+        - active: The chunk the user is currently typing (no comma)
+        - start_pos: The start index of active within the full text
+    Args:
+        text:
+
+    Returns:
+
+    """
+    last_comma = text.rfind(",")
+    if last_comma == -1:
+        prefix = ""
+        active = text
+        start_pos = 0
+        return prefix, active, start_pos
+
+    prefix_end = last_comma + 1
+    prefix = text[:prefix_end]
+    i = prefix_end
+    while i < len(text) and text[i].isspace():
+        i += 1
+    prefix = text[:i]
+    active = text[i:]
+    start_pos = i
+    return prefix, active, start_pos
+
+
+def _simple_fuzzy_score(needle: str, haystack: str) -> int:
+    """
+    Lightweight fuzzy score with no external dependencies.
+    Higher is better.  Range is 0...100.
+    Args:
+        needle: The search term to match within the haystack
+        haystack: The text to search for needle within
+
+    Returns:
+        An integer score indicating how well needle matches haystack
+    """
+    if not needle:
+        return 1
+    if haystack.startswith(needle):
+        return 100
+    if needle in haystack:
+        return 75
+    it = iter(haystack)
+    if all(ch in it for ch in needle):
+        return 55
+    return 0
+
+
+@dataclass
+class TagCompleterConfig:
+    min_score: int = 1
+    max_results: int = 12
+    case_insensitive: bool = True
+
+
+class TagCompleter(Completer):
+    """
+    Implements a tag completion mechanism for input fields.
+
+    This class provides dynamic suggestions for completing partial user inputs based on a
+    predefined pool of tags. The suggestions are context-aware, configurable, and sorted
+    by relevance. It is specifically designed for scenarios where inputs consist of a
+    comma-separated list of tags.
+
+    Attributes:
+        _get_tags (Callable[[str], Sequence[str]]): A function that retrieves the list of
+            available tags based on the search query provided.
+        _config (TagCompleterConfig): Configuration object that determines completion
+            behavior, including case sensitivity, scoring thresholds, and maximum results.
+    """
+
+    def __init__(
+        self,
+        get_tags: Callable[[str], Sequence[str]],
+        config: TagCompleterConfig | None = None,
+    ):
+        self._get_tags = get_tags
+        self._config = config if config is not None else TagCompleterConfig()
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        """
+        Generate completions for a partial text input based on a list of pre-defined tags.
+
+        This method processes the input text before the cursor, normalizes it based on
+        configuration settings, and evaluates potential completions from a pool of tags.
+        Completions are filtered and sorted by relevance, and only unique, unused tags
+        meeting a minimum score threshold are suggested.
+
+        Args:
+            document (Document): The input context containing the text typed by the user.
+            complete_event (CompleteEvent): Event instance providing additional
+                information about the completion trigger.
+
+        Yields:
+            Completion: A generator of Completion objects, each containing a potential
+                completion string, its display text, and the position within the text
+                where it should be applied.
+        """
+        text = document.text_before_cursor
+        prefix, active, active_start = _split_csv_like(text)
+
+        active_norm = (
+            _normalize_tag(active) if self._config.case_insensitive else active.strip()
+        )
+        if self._config.case_insensitive:
+            tag_pool = [(t, _normalize_tag(t)) for t in self._get_tags(active)]
+        else:
+            tag_pool = [(t, t.strip()) for t in self._get_tags(active)]
+
+        # Do not suggest tags already used in the list
+        already_raw = prefix.split(",")
+        already = {_normalize_tag(t) for t in already_raw if t.strip()}
+        scored: list[Tuple[int, str]] = []
+
+        for original, norm in tag_pool:
+            if not norm:
+                continue
+            if norm in already:
+                continue
+            score = _simple_fuzzy_score(active_norm, norm)
+            if score >= self._config.min_score:
+                scored.append((score, original))
+
+        scored.sort(key=lambda x: (-x[0], x[1].lower()))
+        # Replace only the active chunk, not the entire line
+        # Negative chars to delete before inserting completion
+        start_pos = -len(active)
+
+        for score, tag in scored[: self._config.max_results]:
+            yield Completion(
+                text=tag,
+                start_position=start_pos,
+                display=tag,
+            )

cmdbox/cli/prompts/prompts.py

@@ -0,0 +1,108 @@
+import sys
+from prompt_toolkit import prompt
+
+from cmdbox.cli.prompts.completers import TagCompleter
+from cmdbox.cli.prompts.validators import (
+    AliasValidator,
+    TemplateValidator,
+    TagNameValidator,
+    NameValidator,
+)
+
+
+def prompt_for_confirm(message: str, default: bool = False) -> bool:
+    suffix = " [Y/n]: " if default else " [y/N]: "
+    result = prompt(message + suffix).strip().lower()
+    if result == "":
+        return default
+    return result in ["y", "yes"]
+
+
+def prompt_for_alias(validator: AliasValidator, default: str = "") -> str:
+    alias = prompt("Enter alias: ", validator=validator, default=default)
+    return alias
+
+
+def prompt_for_template(validator: TemplateValidator, default: str = "") -> str:
+    template = prompt(
+        "Enter template: ",
+        prompt_continuation="            ... ",
+        multiline=True,
+        validator=validator,
+        default=default,
+    )
+    return template
+
+
+def prompt_for_description(default: str = "") -> str:
+    description = prompt("Enter description: ", default=default)
+    return description
+
+
+def prompt_for_cwd(default: str = "") -> str:
+    cwd = prompt("Enter working directory: ", default=default)
+    return cwd
+
+
+def prompt_for_shell(default: str = "") -> str:
+    shell = prompt("Enter shell: ", default=default)
+    return shell
+
+
+def prompt_for_timeout(default: str = "") -> str:
+    timeout = prompt("Enter timeout (in seconds): ", default=default)
+    return timeout
+
+
+def prompt_for_name(
+    validator: NameValidator | TagNameValidator, default: str = ""
+) -> str:
+    name = prompt("Enter name: ", validator=validator, default=default)
+    return name
+
+
+def prompt_for_value(default: str = "") -> str:
+    value = prompt("Enter variable value: ", default=default)
+    return value
+
+
+def prompt_for_tags(
+    tag_completer: TagCompleter, validator: TagNameValidator, default: str = ""
+) -> list[str] | None:
+    tags = prompt(
+        "Enter tags (comma-separated): ",
+        completer=tag_completer,
+        validator=validator,
+        default=default,
+    )
+    if not tags:
+        return None
+    return tags.split(",")
+
+
+def prompt_for_missing_var(var_name: str) -> str:
+    """
+    Prompts the user to input a value for a given variable name.
+
+    This function checks if the standard output is a terminal. If it is, the function
+    uses the `prompt()` mechanism to get the input. If standard output is not a terminal
+    (e.g., the command is being run in cbe emit mode), the function writes the prompt to
+    standard error, flushes the stream, and then reads input directly from the console.
+
+    Args:
+        var_name: A string representing the name of the variable for which a value
+            is being requested.
+
+    Returns:
+        A string containing the value entered by the user for the specified variable.
+    """
+    message = f"Enter value for <{var_name}>: "
+
+    # Normal execution
+    if sys.stdout.isatty():
+        return prompt(message)
+
+    # Stdout is a pipe, not tty (e.g. cbe emit mode) - open console directly
+    sys.stderr.write(message)
+    sys.stderr.flush()
+    return sys.stdin.readline().strip("\n")

cmdbox/cli/prompts/validators.py

@@ -0,0 +1,46 @@
+from prompt_toolkit.document import Document
+from prompt_toolkit.validation import Validator, ValidationError
+
+
+class AliasValidator(Validator):
+
+    def validate(self, document: Document) -> None:
+        text = document.text.strip()
+        if text == "":
+            raise ValidationError(message="Alias cannot be empty")
+        if " " in text:
+            raise ValidationError(message="Alias cannot contain spaces")
+        if "<" in text or ">" in text:
+            raise ValidationError(message="Alias cannot contain '<' or '>' characters")
+
+
+class TemplateValidator(Validator):
+
+    def validate(self, document: Document) -> None:
+        text = document.text.strip()
+        if text == "":
+            raise ValidationError(message="Template cannot be empty")
+
+
+class NameValidator(Validator):
+
+    def validate(self, document: Document) -> None:
+        text = document.text.strip()
+        if text == "":
+            raise ValidationError(message="Name cannot be empty")
+        if " " in text:
+            raise ValidationError(message="Name cannot contain spaces")
+        if "<" in text or ">" in text:
+            raise ValidationError(message="Name cannot contain '<' or '>' characters")
+
+
+class TagNameValidator(Validator):
+
+    def validate(self, document: Document) -> None:
+        text = document.text.strip()
+        if " " in text:
+            raise ValidationError(message="Tag name cannot contain spaces")
+        if "<" in text or ">" in text:
+            raise ValidationError(
+                message="Tag name cannot contain '<' or '>' characters"
+            )

cmdbox/cli/ui/console.py

@@ -0,0 +1,31 @@
+from rich.console import Console
+
+
+class ConsoleUI:
+
+    def __init__(self, theme, *, force_color=None):
+        self._console = Console(
+            theme=theme, force_terminal=force_color, highlight=False
+        )
+        self._theme = theme
+
+    def print(self, thing) -> None:
+        self._console.print(thing)
+
+    def success(self, message: str) -> None:
+        self._console.print(message, style="status.success")
+
+    def warning(self, message: str) -> None:
+        self._console.print(message, style="status.warning")
+
+    def error(self, message: str) -> None:
+        self._console.print(message, style="status.error")
+
+    def info(self, message: str) -> None:
+        self._console.print(message, style="status.info")
+
+    def muted(self, message: str) -> None:
+        self._console.print(message, style="status.muted")
+
+    def debug(self, message: str) -> None:
+        self._console.print(message, style="status.debug")