cmdbox-cli 1.0.0__py3-none-any.whl

cmdbox/cli/ui/editor.py

@@ -0,0 +1,141 @@
+import logging
+import os
+import shlex
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+from prompt_toolkit import Application
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import Layout
+from prompt_toolkit.styles import Style
+from prompt_toolkit.widgets import TextArea, Frame
+
+log = logging.getLogger(__name__)
+
+
+class EditCanceled(Exception):
+    pass
+
+
+def edit_text_fullscreen(initial_text: str, title: str = "Edit") -> str:
+    """
+    Opens a fullscreen text editor in the terminal for the user to edit the
+    provided text.
+
+    This function creates an interactive fullscreen text editor with options for
+    saving or canceling edits. The user can press `Ctrl+S` to save changes,
+    `Ctrl+Q` or `Esc` to cancel editing, and directly work with a text area that
+    supports multiline editing, scrolling, and line numbers.
+
+    Args:
+        initial_text (str): The initial text content to be edited by the user.
+        title (str, optional): The title of the editor window. Defaults to "Edit".
+
+    Returns:
+        str: The edited text after the user saves and exits the editor.
+    """
+    log.info(
+        "Editing text in fullscreen editor for '%s'. text_length=%s",
+        title,
+        len(initial_text),
+    )
+    kb = KeyBindings()
+
+    text_area = TextArea(
+        text=initial_text,
+        multiline=True,
+        scrollbar=True,
+        line_numbers=True,
+        wrap_lines=False,
+    )
+
+    @kb.add("c-s")
+    def _save(event):
+        event.app.exit(result=text_area.text)
+
+    @kb.add("c-q")
+    @kb.add("escape")
+    def _cancel(event):
+        event.app.exit(exception=EditCanceled())
+
+    root = Frame(text_area, title=f"{title} (Ctrl+S to save, Esc to cancel)")
+    app = Application(
+        layout=Layout(root),
+        key_bindings=kb,
+        full_screen=True,
+        mouse_support=True,
+        style=Style.from_dict({}),
+    )
+
+    return app.run()
+
+
+def edit_text_in_editor(
+    initial_text: str, suffix: str = ".txt", title_hint: str | None = None
+) -> str:
+    """
+    Opens the given initial text in a temporary file for editing using a text editor
+    resolved by the system. The final text, after editing, is returned as a string.
+
+    Args:
+        initial_text: The initial text content to populate the temporary file with.
+        suffix: The file suffix/extension to use for the temporary file. Defaults to ".txt".
+        title_hint: Optional hint for the editor window title.
+
+    Returns:
+        Edited content as a string after modifications in the editor.
+
+    Raises:
+        RuntimeError: If the editor cannot be found or launched properly.
+    """
+    log.info("Opening text editor for '%s'", title_hint)
+    editor_cmd = resolve_editor()
+    log.debug("Using editor: %s", editor_cmd)
+
+    with tempfile.TemporaryDirectory(prefix="cb_edit_") as td:
+        path = Path(td) / f"edit{suffix}"
+        path.write_text(initial_text, encoding="utf-8")
+        cmd = [*editor_cmd, str(path)]
+
+        env = os.environ.copy()
+        if title_hint:
+            env["CB_EDIT_TITLE"] = title_hint
+
+        try:
+            subprocess.run(cmd, check=False, env=env)
+        except FileNotFoundError as e:
+            log.error("Unable to find editor %s", editor_cmd)
+            raise RuntimeError(f"Unable to find editor: {editor_cmd}") from e
+
+        return path.read_text(encoding="utf-8")
+
+
+def resolve_editor() -> list[str]:
+    """
+    Determines the command used to open a text editor based on user environment
+    or available system defaults.
+
+    If an editor is specified in the `VISUAL` or `EDITOR` environment variables,
+    this value is used. Otherwise, the function falls back to platform-specific
+    default editors or searches for common command-line editors available on the
+    system.
+
+    Returns:
+        list[str]: A list representing the command to open a text editor.
+        For example, it may contain the editor's executable name or path, along
+        with any required arguments.
+    """
+    editor = os.environ.get("VISUAL") or os.environ.get("EDITOR")
+    if editor:
+        return shlex.split(editor)
+
+    if os.name == "nt":
+        return ["notepad"]
+
+    for candidate in ["nano", "vim", "vi"]:
+        if shutil.which(candidate) is not None:
+            return [candidate]
+
+    return ["vi"]

cmdbox/cli/ui/presenters/app_presenter.py

@@ -0,0 +1,8 @@
+from cmdbox.cli.ui.primitives import banner
+
+
+def render_version(version: str):
+    return banner(
+        f"CmdBox {version}",
+        status="info",
+    )

cmdbox/cli/ui/presenters/command_presenter.py

@@ -0,0 +1,168 @@
+import json
+from typing import Sequence, Callable
+
+from cmdbox.cli.ui.primitives import (
+    col,
+    pluralize,
+    table_panel,
+    kv_table,
+    section,
+    tag_block,
+)
+from cmdbox.models import Command
+
+COMMAND_COLUMNS: dict[str, tuple[str, dict, Callable[[Command], object]]] = {
+    "alias": (
+        "Alias",
+        {"style": "entity.name", "no_wrap": True},
+        lambda c: c.alias,
+    ),
+    "template": (
+        "Template",
+        {"style": "code.inline", "overflow": "fold"},
+        lambda c: c.template,
+    ),
+    "description": (
+        "Description",
+        {"overflow": "fold"},
+        lambda c: c.description,
+    ),
+    "cwd": (
+        "Working Directory",
+        {"overflow": "fold"},
+        lambda c: c.cwd,
+    ),
+    "shell": (
+        "Shell",
+        {"no_wrap": True},
+        lambda c: c.shell,
+    ),
+    "env": (
+        "Environment",
+        {"overflow": "fold"},
+        lambda c: format_env(c.env),
+    ),
+    "timeout": (
+        "Timeout",
+        {"no_wrap": True},
+        lambda c: f"{c.timeout}s" if c.timeout is not None else None,
+    ),
+    "used": (
+        "Used",
+        {"style": "entity.count", "no_wrap": True, "justify": "right"},
+        lambda c: c.used,
+    ),
+    "last_used": (
+        "Last Used",
+        {"style": "entity.time", "no_wrap": True},
+        lambda c: c.last_used,
+    ),
+    "date_created": (
+        "Created",
+        {"style": "entity.time", "no_wrap": True},
+        lambda c: c.date_created,
+    ),
+    "last_updated": (
+        "Updated",
+        {"style": "entity.time", "no_wrap": True},
+        lambda c: c.last_updated,
+    ),
+    "tags": (
+        "Tags",
+        {"overflow": "fold"},
+        lambda c: tag_block([x.tag.name for x in c.tags]),
+    ),
+}
+
+DEFAULT_FIELDS = ["alias", "template", "description"]
+
+
+def render_command_created(command: Command):
+    rendered_command = render_command(command)
+    return section(
+        title=f"Command '{command.alias}' created",
+        body=rendered_command,
+        border_style="status.success",
+    )
+
+
+def render_command(command: Command):
+    # Conditional fields will only be shown if they are not None
+    conditional_fields = ["cwd", "shell", "env", "timeout"]
+    rows = []
+    for key, value in COMMAND_COLUMNS.items():
+        header, _, extractor = value
+        extracted_value = extractor(command)
+        if key in conditional_fields and extracted_value is None:
+            continue
+        rows.append((header, extracted_value))
+    cmd_display = kv_table(rows)
+    return cmd_display
+
+
+def render_command_list(
+    commands: Sequence[Command], *, title: str = None, fields: list[str] | None = None
+):
+    active_fields = fields or DEFAULT_FIELDS
+    active_fields = [f for f in active_fields if f in COMMAND_COLUMNS]
+
+    columns = []
+    extractors = []
+
+    for field in active_fields:
+        header, col_args, extractor = COMMAND_COLUMNS[field]
+        columns.append(col(header, **col_args))
+        extractors.append(extractor)
+
+    rows = [tuple(extractor(c) for extractor in extractors) for c in commands]
+
+    caption = f"{pluralize(len(commands), 'command')} found"
+
+    return table_panel(
+        title=title or "Commands",
+        columns=columns,
+        rows=rows,
+        caption=caption,
+    )
+
+
+def render_command_updated(command: Command):
+    rendered_command = render_command(command)
+    return section(
+        title=f"Command '{command.alias}' updated",
+        body=rendered_command,
+        border_style="status.success",
+    )
+
+
+def render_command_deleted(command: Command):
+    rendered_command = render_command(command)
+    return section(
+        title=f"Command '{command.alias}' deleted",
+        body=rendered_command,
+        border_style="status.success",
+    )
+
+
+def format_env(env: str | None) -> str | None:
+    """
+    Formats the provided environment string by parsing it as JSON and converting the
+    key-value pairs into a newline-separated string. If the string is not valid JSON
+    or parsing fails, the original string is returned.
+
+    Args:
+        env (str | None): A string representing the environment in JSON format, or
+            None if no environment is provided.
+
+    Returns:
+        str | None: A formatted string with key-value pairs separated by newlines
+            if the input was parsed successfully; otherwise, the original string or
+            None if the input was None.
+    """
+    if not env:
+        return None
+    try:
+        parsed = json.loads(env)
+        return "\n".join(f"{k}={v}" for k, v in parsed.items())
+    except (json.JSONDecodeError, AttributeError):
+        return env

cmdbox/cli/ui/presenters/history_presenter.py

@@ -0,0 +1,83 @@
+from rich.text import Text
+
+from cmdbox.cli.ui.primitives import (
+    to_text,
+    col,
+    table_panel,
+    pluralize,
+    kv_table,
+    section,
+    status_line,
+)
+from cmdbox.models import CommandHistory
+
+
+def _short_id(entry: CommandHistory) -> str:
+    return entry.id[:6]
+
+
+def _format_exit(exit_code: int | None) -> Text:
+    if exit_code is None:
+        return to_text("—", style="ui.muted")
+    if exit_code == 0:
+        return to_text("0", style="status.success")
+    return to_text(str(exit_code), style="status.error")
+
+
+HISTORY_LIST_COLUMNS = [
+    col("#", style="ui.muted", justify="right", no_wrap=True),
+    col("ID", style="entity.id", no_wrap=True),
+    col("Alias", style="entity.name", no_wrap=True),
+    col("Ran At", style="entity.time", no_wrap=True),
+    col("Exit", justify="center", no_wrap=True),
+]
+
+
+def _list_rows(entries: list[CommandHistory]) -> list[tuple]:
+    return [
+        (
+            str(i),
+            _short_id(entry),
+            entry.alias,
+            to_text(entry.ran_at),
+            _format_exit(entry.exit_code),
+        )
+        for i, entry in enumerate(entries, start=1)
+    ]
+
+
+def render_history_list(entries: list[CommandHistory]):
+    return table_panel(
+        title="History",
+        columns=HISTORY_LIST_COLUMNS,
+        rows=_list_rows(entries),
+        caption=pluralize(len(entries), "entry", "entries"),
+    )
+
+
+def render_history_entry(entry: CommandHistory, variables: dict | None):
+    rows = [
+        ("ID", to_text(_short_id(entry), style="entity.id")),
+        ("Alias", to_text(entry.alias, style="entity.name")),
+        ("Ran At", to_text(entry.ran_at, style="entity.time")),
+        ("Exit Code", _format_exit(entry.exit_code)),
+        ("Template", to_text(entry.template, style="code.inline")),
+        ("Resolved", to_text(entry.resolved, style="code.inline")),
+    ]
+
+    if variables:
+        for k, v in variables.items():
+            rows.append((f"  <{k}>", to_text(v, style="code.inline")))
+
+    return section(
+        title=f"History Entry - {_short_id(entry)}",
+        body=kv_table(rows),
+    )
+
+
+def render_history_cleared(count: int, alias: str | None):
+    scope = f" for '{alias}'" if alias else ""
+    return status_line(
+        f"Cleared {pluralize(count, 'entry', 'entries')}{scope}.",
+        status="success",
+    )

cmdbox/cli/ui/presenters/init_instructions.py

@@ -0,0 +1,52 @@
+import os
+from pathlib import Path
+
+"""
+Instructions for installing the snippet into the user's shell configuration file.
+"""
+
+
+bash_path = os.path.join(Path.home(), ".bashrc")
+bash = [
+    f'Locate your shell configuration file (usually located at: "{bash_path}").',
+    "Add the code snippet to the end of the file.",
+    "Restart your shell session for the changes to take effect.",
+]
+
+zsh_path = os.path.join(Path.home(), ".zshrc")
+zsh = [
+    f'Locate your shell configuration file (usually located at: "{zsh_path}").',
+    "Add the code snippet to the end of the file.",
+    "Restart your shell session for the changes to take effect.",
+]
+
+fish_path = os.path.join(Path.home(), ".config", "fish", "config.fish")
+fish = [
+    f'Locate your shell configuration file (usually located at: "{fish_path}").',
+    "Add the code snippet to the end of the file.",
+    "Restart your shell session for the changes to take effect.",
+]
+
+powershell_path = os.path.join(
+    Path.home(), "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1"
+)
+powershell = [
+    f'Locate your powershell configuration file (usually located at: "{powershell_path}"). ',
+    "If you do not find the correct configuration file here, you can run the command `$PROFILE` from your powershell terminal to output the exact location.",
+    "Add the code snippet to the end of the file.",
+    "Restart your shell session for the changes to take effect.",
+]
+
+pwsh = powershell
+
+cmd = [
+    "cmd.exe integration is only supported as a wrapper script, not a profile snippet.",
+    'Create a file named "cbe.cmd" (the file can be created anywhere on your system).',
+    "Paste the snippet into this file and save it.",
+    "Ensure the file is on your PATH.",
+    "Restart your shell for changes to take effect.",
+]
+
+
+def get_instructions(shell: str) -> list[str]:
+    return globals()[shell.lower()]

cmdbox/cli/ui/presenters/init_presenter.py

@@ -0,0 +1,57 @@
+from cmdbox.cli.ui.presenters.init_instructions import get_instructions
+from cmdbox.cli.ui.primitives import (
+    section,
+    to_text,
+    stack,
+    spacer,
+    bullet_list,
+    banner,
+)
+
+
+def render_install_instructions(
+    install_snippet: str,
+    shell: str,
+    *,
+    title: str = "Installation Instructions",
+    include_help_text: bool = True,
+):
+    snippet = to_text(install_snippet, style="code.block")
+    instruction_text = get_instructions(shell)
+    instructions = section(
+        title="What to do with this snippet",
+        body=bullet_list(instruction_text, item_style="ui.muted"),
+        border_style="status.info",
+    )
+    if include_help_text:
+        help_text = section(
+            title="Automate",
+            body=to_text(
+                "Re-run the `init` command with the `--install` flag to automatically install the snippet into your configuration file",
+                style="ui.muted",
+            ),
+        )
+    else:
+        help_text = ""
+    body = stack(snippet, spacer(0), instructions, spacer(0), help_text)
+    return section(
+        title=title,
+        body=body,
+        border_style="ui.border",
+    )
+
+
+def render_install_success():
+    return banner(
+        title="Shell integration installed",
+        subtitle="Restart your shell for changes to take effect",
+        status="success",
+    )
+
+
+def render_shell_output(shell: str):
+    return section(
+        title="Shell detected",
+        body=to_text(shell, style="code.inline"),
+        border_style="status.info",
+    )

cmdbox/cli/ui/presenters/result_presenter.py

@@ -0,0 +1,144 @@
+from rich.text import Text
+
+from cmdbox.cli.ui.primitives import (
+    banner,
+    section,
+    tag_block,
+    stack,
+    spacer,
+    code_block,
+    table_panel,
+    col,
+)
+from cmdbox.repositories.results import TagAttachResult, TagDetachResult
+from cmdbox.resolve.type_defs import ResolveResult
+from cmdbox.runtime.executor import RunContext
+from cmdbox.runtime.results import ExecutionResult
+
+
+def render_execution_result(result: ExecutionResult, *, title: str = "Run"):
+    ok = result.exit_code == 0
+    status = "success" if ok else "error"
+
+    # Wrap stdout border in error color if status is error
+    stdout_border = "ui.border" if ok else "status.error"
+    # If ok, wrap stderr border in warning color, otherwise error
+    stderr_border = "status.error" if not ok else "status.warning"
+
+    parts = [
+        banner(
+            title=title if ok else f"{title} failed",
+            subtitle=f"Exit code: {result.exit_code}",
+            status=status,
+        ),
+        spacer(1),
+        code_block(
+            result.command,
+            title="Command",
+            border_style="ui.border",
+            style="run.command",
+        ),
+    ]
+
+    if result.stdout and result.stdout.strip():
+        parts += [
+            section(
+                "STDOUT",
+                Text(result.stdout.rstrip("\n"), style="run.stdout"),
+                border_style=stdout_border,
+            ),
+        ]
+
+    if result.stderr and result.stderr.strip():
+        parts += [
+            section(
+                "STDERR",
+                Text(result.stderr.rstrip("\n"), style="run.stderr"),
+                border_style=stderr_border,
+            ),
+        ]
+
+    return stack(*parts)
+
+
+def render_preview_result(
+    result: ResolveResult,
+    *,
+    title: str = "Preview",
+    show_trace: bool = True,
+    ctx: RunContext = None,
+):
+    parts = [
+        code_block(result.text, title="Resolved command", border_style="run.command"),
+    ]
+
+    if show_trace and result.trace:
+        parts += [spacer(0), _render_trace_steps(result)]
+
+    if ctx:
+        parts += [spacer(0), render_run_context(ctx)]
+
+    return section(
+        title=title,
+        body=stack(*parts),
+        border_style="ui.border",
+    )
+
+
+def render_run_context(ctx: RunContext, *, title: str = "Run context"):
+    return code_block(str(ctx), title=title, border_style="ui.border")
+
+
+def _render_trace_steps(result: ResolveResult):
+    columns = [
+        col("Kind", style="run.trace.kind", no_wrap=True),
+        col("Key", style="run.trace.key", overflow="fold"),
+        col("Expanded to", style="run.trace.value", overflow="fold"),
+    ]
+
+    rows = [(step.kind.name, step.key, step.expanded_to) for step in result.trace]
+
+    table = table_panel(title="Trace", columns=columns, rows=rows)
+    return table
+
+
+def render_tag_attach_result(result: TagAttachResult):
+    added_tag_block = tag_block(tags=result.added)
+    existing_tag_block = tag_block(tags=result.existing, style="tag.pill_muted")
+    renderable = []
+    if len(result.added) > 0:
+        added_section = section(
+            title=f"{len(result.added)} tags added successfully",
+            body=added_tag_block,
+            border_style="status.success",
+        )
+        renderable.append(added_section)
+    if len(result.existing) > 0:
+        existing_section = section(
+            title=f"{len(result.existing)} tags already exist",
+            body=existing_tag_block,
+            border_style="ui.dim",
+        )
+        renderable.append(existing_section)
+    return stack(*renderable)
+
+
+def render_tag_detach_result(result: TagDetachResult):
+    removed_tag_block = tag_block(tags=result.removed)
+    not_attached_tag_block = tag_block(tags=result.not_attached, style="tag.pill_muted")
+    renderable = []
+    if len(result.removed) > 0:
+        removed_section = section(
+            title=f"{len(result.removed)} tags removed successfully",
+            body=removed_tag_block,
+            border_style="status.success",
+        )
+        renderable.append(removed_section)
+    if len(result.not_attached) > 0:
+        not_attached_section = section(
+            title=f"{len(result.not_attached)} tags not attached",
+            body=not_attached_tag_block,
+            border_style="ui.dim",
+        )
+        renderable.append(not_attached_section)
+    return stack(*renderable)