falyx 0.1.20__tar.gz → 0.1.22__tar.gz

{falyx-0.1.20 → falyx-0.1.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: falyx
-Version: 0.1.20
+Version: 0.1.22
 Summary: Reliable and introspectable async CLI action framework.
 License: MIT
 Author: Roland Thomas Jr

{falyx-0.1.20 → falyx-0.1.22}/falyx/__main__.py

@@ -14,6 +14,7 @@ from typing import Any
 from falyx.config import loader
 from falyx.falyx import Falyx
 from falyx.parsers import FalyxParsers, get_arg_parsers
+from falyx.themes.colors import OneColors
 
 
 def find_falyx_config() -> Path | None:
@@ -71,6 +72,7 @@ def run(args: Namespace) -> Any:
         title="🛠️ Config-Driven CLI",
         cli_args=args,
         columns=4,
+        prompt=[(OneColors.BLUE_b, "FALYX > ")],
     )
     flx.add_commands(loader(bootstrap_path))
     return asyncio.run(flx.run())

{falyx-0.1.20 → falyx-0.1.22}/falyx/action.py

@@ -64,6 +64,7 @@ class BaseAction(ABC):
     def __init__(
         self,
         name: str,
+        *,
         hooks: HookManager | None = None,
         inject_last_result: bool = False,
         inject_into: str = "last_result",
@@ -182,6 +183,7 @@ class Action(BaseAction):
         self,
         name: str,
         action: Callable[..., Any],
+        *,
         rollback: Callable[..., Any] | None = None,
         args: tuple[Any, ...] = (),
         kwargs: dict[str, Any] | None = None,
@@ -191,7 +193,12 @@ class Action(BaseAction):
         retry: bool = False,
         retry_policy: RetryPolicy | None = None,
     ) -> None:
-        super().__init__(name, hooks, inject_last_result, inject_into)
+        super().__init__(
+            name,
+            hooks=hooks,
+            inject_last_result=inject_last_result,
+            inject_into=inject_into,
+        )
         self.action = action
         self.rollback = rollback
         self.args = args
@@ -422,13 +429,19 @@ class ChainedAction(BaseAction, ActionListMixin):
         self,
         name: str,
         actions: list[BaseAction | Any] | None = None,
+        *,
         hooks: HookManager | None = None,
         inject_last_result: bool = False,
         inject_into: str = "last_result",
         auto_inject: bool = False,
         return_list: bool = False,
     ) -> None:
-        super().__init__(name, hooks, inject_last_result, inject_into)
+        super().__init__(
+            name,
+            hooks=hooks,
+            inject_last_result=inject_last_result,
+            inject_into=inject_into,
+        )
         ActionListMixin.__init__(self)
         self.auto_inject = auto_inject
         self.return_list = return_list
@@ -608,11 +621,17 @@ class ActionGroup(BaseAction, ActionListMixin):
         self,
         name: str,
         actions: list[BaseAction] | None = None,
+        *,
         hooks: HookManager | None = None,
         inject_last_result: bool = False,
         inject_into: str = "last_result",
     ):
-        super().__init__(name, hooks, inject_last_result, inject_into)
+        super().__init__(
+            name,
+            hooks=hooks,
+            inject_last_result=inject_last_result,
+            inject_into=inject_into,
+        )
         ActionListMixin.__init__(self)
         if actions:
             self.set_actions(actions)
@@ -730,7 +749,8 @@ class ProcessAction(BaseAction):
     def __init__(
         self,
         name: str,
-        func: Callable[..., Any],
+        action: Callable[..., Any],
+        *,
         args: tuple = (),
         kwargs: dict[str, Any] | None = None,
         hooks: HookManager | None = None,
@@ -738,8 +758,13 @@ class ProcessAction(BaseAction):
         inject_last_result: bool = False,
         inject_into: str = "last_result",
     ):
-        super().__init__(name, hooks, inject_last_result, inject_into)
-        self.func = func
+        super().__init__(
+            name,
+            hooks=hooks,
+            inject_last_result=inject_last_result,
+            inject_into=inject_into,
+        )
+        self.action = action
         self.args = args
         self.kwargs = kwargs or {}
         self.executor = executor or ProcessPoolExecutor()
@@ -767,7 +792,7 @@ class ProcessAction(BaseAction):
         try:
             await self.hooks.trigger(HookType.BEFORE, context)
             result = await loop.run_in_executor(
-                self.executor, partial(self.func, *combined_args, **combined_kwargs)
+                self.executor, partial(self.action, *combined_args, **combined_kwargs)
             )
             context.result = result
             await self.hooks.trigger(HookType.ON_SUCCESS, context)
@@ -806,6 +831,6 @@ class ProcessAction(BaseAction):
 
     def __str__(self) -> str:
         return (
-            f"ProcessAction(name={self.name!r}, func={getattr(self.func, '__name__', repr(self.func))}, "
+            f"ProcessAction(name={self.name!r}, action={getattr(self.action, '__name__', repr(self.action))}, "
             f"args={self.args!r}, kwargs={self.kwargs!r})"
         )

{falyx-0.1.20 → falyx-0.1.22}/falyx/bottom_bar.py

@@ -30,7 +30,7 @@ class BottomBar:
         key_validator: Callable[[str], bool] | None = None,
     ) -> None:
         self.columns = columns
-        self.console = Console()
+        self.console = Console(color_system="auto")
         self._named_items: dict[str, Callable[[], HTML]] = {}
         self._value_getters: dict[str, Callable[[], Any]] = CaseInsensitiveDict()
         self.toggle_keys: list[str] = []

{falyx-0.1.20 → falyx-0.1.22}/falyx/command.py

@@ -40,7 +40,7 @@ from falyx.retry_utils import enable_retries_recursively
 from falyx.themes.colors import OneColors
 from falyx.utils import _noop, confirm_async, ensure_async, logger
 
-console = Console()
+console = Console(color_system="auto")
 
 
 class Command(BaseModel):
@@ -272,15 +272,21 @@ class Command(BaseModel):
         if hasattr(self.action, "preview") and callable(self.action.preview):
             tree = Tree(label)
             await self.action.preview(parent=tree)
+            if self.help_text:
+                tree.add(f"[dim]💡 {self.help_text}[/dim]")
             console.print(tree)
         elif callable(self.action) and not isinstance(self.action, BaseAction):
             console.print(f"{label}")
+            if self.help_text:
+                console.print(f"[dim]💡 {self.help_text}[/dim]")
             console.print(
                 f"[{OneColors.LIGHT_RED_b}]→ Would call:[/] {self.action.__name__}"
                 f"[dim](args={self.args}, kwargs={self.kwargs})[/dim]"
             )
         else:
             console.print(f"{label}")
+            if self.help_text:
+                console.print(f"[dim]💡 {self.help_text}[/dim]")
             console.print(
                 f"[{OneColors.DARK_RED}]⚠️ Action is not callable or lacks a preview method.[/]"
             )

{falyx-0.1.20 → falyx-0.1.22}/falyx/config.py

@@ -3,15 +3,21 @@
 Configuration loader for Falyx CLI commands."""
 
 import importlib
+import sys
 from pathlib import Path
 from typing import Any
 
 import toml
 import yaml
+from rich.console import Console
 
 from falyx.action import Action, BaseAction
 from falyx.command import Command
 from falyx.retry import RetryPolicy
+from falyx.themes.colors import OneColors
+from falyx.utils import logger
+
+console = Console(color_system="auto")
 
 
 def wrap_if_needed(obj: Any, name=None) -> BaseAction | Command:
@@ -30,9 +36,28 @@ def import_action(dotted_path: str) -> Any:
     """Dynamically imports a callable from a dotted path like 'my.module.func'."""
     module_path, _, attr = dotted_path.rpartition(".")
     if not module_path:
-        raise ValueError(f"Invalid action path: {dotted_path}")
-    module = importlib.import_module(module_path)
-    return getattr(module, attr)
+        console.print(f"[{OneColors.DARK_RED}]❌ Invalid action path:[/] {dotted_path}")
+        sys.exit(1)
+    try:
+        module = importlib.import_module(module_path)
+    except ModuleNotFoundError as error:
+        logger.error("Failed to import module '%s': %s", module_path, error)
+        console.print(
+            f"[{OneColors.DARK_RED}]❌ Could not import '{dotted_path}': {error}[/]\n"
+            f"[{OneColors.COMMENT_GREY}]Ensure the module is installed and discoverable via PYTHONPATH."
+        )
+        sys.exit(1)
+    try:
+        action = getattr(module, attr)
+    except AttributeError as error:
+        logger.error(
+            "Module '%s' does not have attribute '%s': %s", module_path, attr, error
+        )
+        console.print(
+            f"[{OneColors.DARK_RED}]❌ Module '{module_path}' has no attribute '{attr}': {error}[/]"
+        )
+        sys.exit(1)
+    return action
 
 
 def loader(file_path: Path | str) -> list[dict[str, Any]]:

{falyx-0.1.20 → falyx-0.1.22}/falyx/execution_registry.py

@@ -15,7 +15,7 @@ from falyx.utils import logger
 class ExecutionRegistry:
     _store_by_name: Dict[str, List[ExecutionContext]] = defaultdict(list)
     _store_all: List[ExecutionContext] = []
-    _console = Console(color_system="truecolor")
+    _console = Console(color_system="auto")
 
     @classmethod
     def record(cls, context: ExecutionContext):

{falyx-0.1.20 → falyx-0.1.22}/falyx/falyx.py

@@ -110,12 +110,12 @@ class Falyx:
         register_all_hooks(): Register hooks across all commands and submenus.
         debug_hooks(): Log hook registration for debugging.
         build_default_table(): Construct the standard Rich table layout.
-
     """
 
     def __init__(
         self,
         title: str | Markdown = "Menu",
+        *,
         prompt: str | AnyFormattedText = "> ",
         columns: int = 3,
         bottom_bar: BottomBar | str | Callable[[], Any] | None = None,
@@ -143,7 +143,7 @@ class Falyx:
         self.help_command: Command | None = (
             self._get_help_command() if include_help_command else None
         )
-        self.console: Console = Console(color_system="truecolor", theme=get_nord_theme())
+        self.console: Console = Console(color_system="auto", theme=get_nord_theme())
         self.welcome_message: str | Markdown | dict[str, Any] = welcome_message
         self.exit_message: str | Markdown | dict[str, Any] = exit_message
         self.hooks: HookManager = HookManager()
@@ -283,7 +283,7 @@ class Falyx:
         self.console.print(table, justify="center")
         if self.mode == FalyxMode.MENU:
             self.console.print(
-                f"📦 Tip: Type '[{OneColors.LIGHT_YELLOW}]?[KEY][/]' to preview a command before running it.\n",
+                f"📦 Tip: '[{OneColors.LIGHT_YELLOW}]?[KEY][/]' to preview a command before running it.\n",
                 justify="center",
             )
 
@@ -343,7 +343,9 @@ class Falyx:
         error_message = " ".join(message_lines)
 
         def validator(text):
-            _, choice = self.get_command(text, from_validate=True)
+            is_preview, choice = self.get_command(text, from_validate=True)
+            if is_preview and choice is None:
+                return True
             return True if choice else False
 
         return Validator.from_callable(
@@ -549,7 +551,7 @@ class Falyx:
         )
 
     def add_submenu(
-        self, key: str, description: str, submenu: "Falyx", style: str = OneColors.CYAN
+        self, key: str, description: str, submenu: "Falyx", *, style: str = OneColors.CYAN
     ) -> None:
         """Adds a submenu to the menu."""
         if not isinstance(submenu, Falyx):
@@ -568,6 +570,7 @@ class Falyx:
         key: str,
         description: str,
         action: BaseAction | Callable[[], Any],
+        *,
         args: tuple = (),
         kwargs: dict[str, Any] = {},
         hidden: bool = False,
@@ -693,6 +696,13 @@ class Falyx:
     ) -> tuple[bool, Command | None]:
         """Returns the selected command based on user input. Supports keys, aliases, and abbreviations."""
         is_preview, choice = self.parse_preview_command(choice)
+        if is_preview and not choice:
+            if not from_validate:
+                self.console.print(
+                    f"[{OneColors.DARK_RED}]❌ You must enter a command for preview mode.[/]"
+                )
+            return is_preview, None
+
         choice = choice.upper()
         name_map = self._name_map
 
@@ -787,12 +797,17 @@ class Falyx:
     async def run_key(self, command_key: str, return_context: bool = False) -> Any:
         """Run a command by key without displaying the menu (non-interactive mode)."""
         self.debug_hooks()
-        _, selected_command = self.get_command(command_key)
+        is_preview, selected_command = self.get_command(command_key)
         self.last_run_command = selected_command
 
         if not selected_command:
             return None
 
+        if is_preview:
+            logger.info(f"Preview command '{selected_command.key}' selected.")
+            await selected_command.preview()
+            return None
+
         logger.info(
             "[run_key] 🚀 Executing: %s — %s",
             selected_command.key,
@@ -942,11 +957,14 @@ class Falyx:
 
         if self.cli_args.command == "run":
             self.mode = FalyxMode.RUN
-            _, command = self.get_command(self.cli_args.name)
+            is_preview, command = self.get_command(self.cli_args.name)
+            if is_preview:
+                if command is None:
+                    sys.exit(1)
+                logger.info(f"Preview command '{command.key}' selected.")
+                await command.preview()
+                sys.exit(0)
             if not command:
-                self.console.print(
-                    f"[{OneColors.DARK_RED}]❌ Command '{self.cli_args.name}' not found.[/]"
-                )
                 sys.exit(1)
             self._set_retry_policy(command)
             try:
@@ -954,6 +972,9 @@ class Falyx:
             except FalyxError as error:
                 self.console.print(f"[{OneColors.DARK_RED}]❌ Error: {error}[/]")
                 sys.exit(1)
+
+            if self.cli_args.summary:
+                er.summary()
             sys.exit(0)
 
         if self.cli_args.command == "run-all":
@@ -975,6 +996,10 @@ class Falyx:
             for cmd in matching:
                 self._set_retry_policy(cmd)
                 await self.run_key(cmd.key)
+
+            if self.cli_args.summary:
+                er.summary()
+
             sys.exit(0)
 
         await self.menu()

{falyx-0.1.20 → falyx-0.1.22}/falyx/io_action.py

@@ -20,7 +20,6 @@ import subprocess
 import sys
 from typing import Any
 
-from rich.console import Console
 from rich.tree import Tree
 
 from falyx.action import BaseAction
@@ -31,8 +30,6 @@ from falyx.hook_manager import HookManager, HookType
 from falyx.themes.colors import OneColors
 from falyx.utils import logger
 
-console = Console()
-
 
 class BaseIOAction(BaseAction):
     """
@@ -62,6 +59,7 @@ class BaseIOAction(BaseAction):
     def __init__(
         self,
         name: str,
+        *,
         hooks: HookManager | None = None,
         mode: str = "buffered",
         logging_hooks: bool = True,
@@ -172,22 +170,7 @@ class BaseIOAction(BaseAction):
         if parent:
             parent.add("".join(label))
         else:
-            console.print(Tree("".join(label)))
-
-
-class UppercaseIO(BaseIOAction):
-    def from_input(self, raw: str | bytes) -> str:
-        if not isinstance(raw, (str, bytes)):
-            raise TypeError(
-                f"{self.name} expected str or bytes input, got {type(raw).__name__}"
-            )
-        return raw.strip() if isinstance(raw, str) else raw.decode("utf-8").strip()
-
-    async def _run(self, parsed_input: str, *args, **kwargs) -> str:
-        return parsed_input.upper()
-
-    def to_output(self, data: str) -> str:
-        return data + "\n"
+            self.console.print(Tree("".join(label)))
 
 
 class ShellAction(BaseIOAction):
@@ -247,41 +230,9 @@ class ShellAction(BaseIOAction):
         if parent:
             parent.add("".join(label))
         else:
-            console.print(Tree("".join(label)))
+            self.console.print(Tree("".join(label)))
 
     def __str__(self):
         return (
             f"ShellAction(name={self.name!r}, command_template={self.command_template!r})"
         )
-
-
-class GrepAction(BaseIOAction):
-    def __init__(self, name: str, pattern: str, **kwargs):
-        super().__init__(name=name, **kwargs)
-        self.pattern = pattern
-
-    def from_input(self, raw: str | bytes) -> str:
-        if not isinstance(raw, (str, bytes)):
-            raise TypeError(
-                f"{self.name} expected str or bytes input, got {type(raw).__name__}"
-            )
-        return raw.strip() if isinstance(raw, str) else raw.decode("utf-8").strip()
-
-    async def _run(self, parsed_input: str) -> str:
-        command = ["grep", "-n", self.pattern]
-        process = subprocess.Popen(
-            command,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-        stdout, stderr = process.communicate(input=parsed_input)
-        if process.returncode == 1:
-            return ""
-        if process.returncode != 0:
-            raise RuntimeError(stderr.strip())
-        return stdout.strip()
-
-    def to_output(self, result: str) -> str:
-        return result

{falyx-0.1.20 → falyx-0.1.22}/falyx/menu_action.py

@@ -45,7 +45,9 @@ class MenuOptionMap(CaseInsensitiveDict):
     RESERVED_KEYS = {"Q", "B"}
 
     def __init__(
-        self, options: dict[str, MenuOption] | None = None, allow_reserved: bool = False
+        self,
+        options: dict[str, MenuOption] | None = None,
+        allow_reserved: bool = False,
     ):
         super().__init__()
         self.allow_reserved = allow_reserved

{falyx-0.1.20 → falyx-0.1.22}/falyx/parsers.py

@@ -36,7 +36,9 @@ def get_arg_parsers(
     prog: str | None = "falyx",
     usage: str | None = None,
     description: str | None = "Falyx CLI - Run structured async command workflows.",
-    epilog: str | None = None,
+    epilog: (
+        str | None
+    ) = "Tip: Use 'falyx run ?[COMMAND]' to preview any command from the CLI.",
     parents: Sequence[ArgumentParser] = [],
     prefix_chars: str = "-",
     fromfile_prefix_chars: str | None = None,
@@ -79,6 +81,11 @@ def get_arg_parsers(
 
     run_parser = subparsers.add_parser("run", help="Run a specific command")
     run_parser.add_argument("name", help="Key, alias, or description of the command")
+    run_parser.add_argument(
+        "--summary",
+        action="store_true",
+        help="Print an execution summary after command completes",
+    )
     run_parser.add_argument(
         "--retries", type=int, help="Number of retries on failure", default=0
     )
@@ -111,6 +118,11 @@ def get_arg_parsers(
         "run-all", help="Run all commands with a given tag"
     )
     run_all_parser.add_argument("-t", "--tag", required=True, help="Tag to match")
+    run_all_parser.add_argument(
+        "--summary",
+        action="store_true",
+        help="Print a summary after all tagged commands run",
+    )
     run_all_parser.add_argument(
         "--retries", type=int, help="Number of retries on failure", default=0
     )

falyx-0.1.22/falyx/select_file_action.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import csv
+import json
+import xml.etree.ElementTree as ET
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+import toml
+import yaml
+from prompt_toolkit import PromptSession
+from rich.console import Console
+from rich.tree import Tree
+
+from falyx.action import BaseAction
+from falyx.context import ExecutionContext
+from falyx.execution_registry import ExecutionRegistry as er
+from falyx.hook_manager import HookType
+from falyx.selection import (
+    SelectionOption,
+    prompt_for_selection,
+    render_selection_dict_table,
+)
+from falyx.themes.colors import OneColors
+from falyx.utils import logger
+
+
+class FileReturnType(Enum):
+    TEXT = "text"
+    PATH = "path"
+    JSON = "json"
+    TOML = "toml"
+    YAML = "yaml"
+    CSV = "csv"
+    XML = "xml"
+
+
+class SelectFileAction(BaseAction):
+    """
+    SelectFileAction allows users to select a file from a directory and return:
+    - file content (as text, JSON, CSV, etc.)
+    - or the file path itself.
+
+    Supported formats: text, json, yaml, toml, csv, xml.
+
+    Useful for:
+    - dynamically loading config files
+    - interacting with user-selected data
+    - chaining file contents into workflows
+
+    Args:
+        name (str): Name of the action.
+        directory (Path | str): Where to search for files.
+        title (str): Title of the selection menu.
+        columns (int): Number of columns in the selection menu.
+        prompt_message (str): Message to display when prompting for selection.
+        style (str): Style for the selection options.
+        suffix_filter (str | None): Restrict to certain file types.
+        return_type (FileReturnType): What to return (path, content, parsed).
+        console (Console | None): Console instance for output.
+        prompt_session (PromptSession | None): Prompt session for user input.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        directory: Path | str = ".",
+        *,
+        title: str = "Select a file",
+        columns: int = 3,
+        prompt_message: str = "Choose > ",
+        style: str = OneColors.WHITE,
+        suffix_filter: str | None = None,
+        return_type: FileReturnType = FileReturnType.PATH,
+        console: Console | None = None,
+        prompt_session: PromptSession | None = None,
+    ):
+        super().__init__(name)
+        self.directory = Path(directory).resolve()
+        self.title = title
+        self.columns = columns
+        self.prompt_message = prompt_message
+        self.suffix_filter = suffix_filter
+        self.style = style
+        self.return_type = return_type
+        self.console = console or Console(color_system="auto")
+        self.prompt_session = prompt_session or PromptSession()
+
+    def get_options(self, files: list[Path]) -> dict[str, SelectionOption]:
+        value: Any
+        options = {}
+        for index, file in enumerate(files):
+            try:
+                if self.return_type == FileReturnType.TEXT:
+                    value = file.read_text(encoding="UTF-8")
+                elif self.return_type == FileReturnType.PATH:
+                    value = file
+                elif self.return_type == FileReturnType.JSON:
+                    value = json.loads(file.read_text(encoding="UTF-8"))
+                elif self.return_type == FileReturnType.TOML:
+                    value = toml.loads(file.read_text(encoding="UTF-8"))
+                elif self.return_type == FileReturnType.YAML:
+                    value = yaml.safe_load(file.read_text(encoding="UTF-8"))
+                elif self.return_type == FileReturnType.CSV:
+                    with open(file, newline="", encoding="UTF-8") as csvfile:
+                        reader = csv.reader(csvfile)
+                        value = list(reader)
+                elif self.return_type == FileReturnType.XML:
+                    tree = ET.parse(file, parser=ET.XMLParser(encoding="UTF-8"))
+                    root = tree.getroot()
+                    value = ET.tostring(root, encoding="unicode")
+                else:
+                    raise ValueError(f"Unsupported return type: {self.return_type}")
+
+                options[str(index)] = SelectionOption(
+                    description=file.name, value=value, style=self.style
+                )
+            except Exception as error:
+                logger.warning("[ERROR] Failed to parse %s: %s", file.name, error)
+        return options
+
+    async def _run(self, *args, **kwargs) -> Any:
+        context = ExecutionContext(name=self.name, args=args, kwargs=kwargs, action=self)
+        context.start_timer()
+        try:
+            await self.hooks.trigger(HookType.BEFORE, context)
+
+            files = [
+                f
+                for f in self.directory.iterdir()
+                if f.is_file()
+                and (self.suffix_filter is None or f.suffix == self.suffix_filter)
+            ]
+            if not files:
+                raise FileNotFoundError("No files found in directory.")
+
+            options = self.get_options(files)
+
+            table = render_selection_dict_table(
+                title=self.title, selections=options, columns=self.columns
+            )
+
+            key = await prompt_for_selection(
+                options.keys(),
+                table,
+                console=self.console,
+                prompt_session=self.prompt_session,
+                prompt_message=self.prompt_message,
+            )
+
+            result = options[key].value
+            context.result = result
+            await self.hooks.trigger(HookType.ON_SUCCESS, context)
+            return result
+        except Exception as error:
+            context.exception = error
+            await self.hooks.trigger(HookType.ON_ERROR, context)
+            raise
+        finally:
+            context.stop_timer()
+            await self.hooks.trigger(HookType.AFTER, context)
+            await self.hooks.trigger(HookType.ON_TEARDOWN, context)
+            er.record(context)
+
+    async def preview(self, parent: Tree | None = None):
+        label = f"[{OneColors.GREEN}]📁 SelectFilesAction[/] '{self.name}'"
+        tree = parent.add(label) if parent else Tree(label)
+
+        tree.add(f"[dim]Directory:[/] {str(self.directory)}")
+        tree.add(f"[dim]Suffix filter:[/] {self.suffix_filter or 'None'}")
+        tree.add(f"[dim]Return type:[/] {self.return_type}")
+        tree.add(f"[dim]Prompt:[/] {self.prompt_message}")
+        tree.add(f"[dim]Columns:[/] {self.columns}")
+        try:
+            files = list(self.directory.iterdir())
+            if self.suffix_filter:
+                files = [f for f in files if f.suffix == self.suffix_filter]
+            sample = files[:10]
+            file_list = tree.add("[dim]Files:[/]")
+            for f in sample:
+                file_list.add(f"[dim]{f.name}[/]")
+            if len(files) > 10:
+                file_list.add(f"[dim]... ({len(files) - 10} more)[/]")
+        except Exception as error:
+            tree.add(f"[bold red]⚠️ Error scanning directory: {error}[/]")
+
+        if not parent:
+            self.console.print(tree)
+
+    def __str__(self) -> str:
+        return (
+            f"SelectFilesAction(name={self.name!r}, dir={str(self.directory)!r}, "
+            f"suffix_filter={self.suffix_filter!r}, return_type={self.return_type})"
+        )

{falyx-0.1.20 → falyx-0.1.22}/falyx/selection.py

@@ -31,6 +31,7 @@ class SelectionOption:
 
 def render_table_base(
     title: str,
+    *,
     caption: str = "",
     columns: int = 4,
     box_style: box.Box = box.SIMPLE,
@@ -71,6 +72,7 @@ def render_table_base(
 def render_selection_grid(
     title: str,
     selections: Sequence[str],
+    *,
     columns: int = 4,
     caption: str = "",
     box_style: box.Box = box.SIMPLE,
@@ -86,19 +88,19 @@ def render_selection_grid(
 ) -> Table:
     """Create a selection table with the given parameters."""
     table = render_table_base(
-        title,
-        caption,
-        columns,
-        box_style,
-        show_lines,
-        show_header,
-        show_footer,
-        style,
-        header_style,
-        footer_style,
-        title_style,
-        caption_style,
-        highlight,
+        title=title,
+        caption=caption,
+        columns=columns,
+        box_style=box_style,
+        show_lines=show_lines,
+        show_header=show_header,
+        show_footer=show_footer,
+        style=style,
+        header_style=header_style,
+        footer_style=footer_style,
+        title_style=title_style,
+        caption_style=caption_style,
+        highlight=highlight,
     )
 
     for chunk in chunks(selections, columns):
@@ -110,6 +112,7 @@ def render_selection_grid(
 def render_selection_indexed_table(
     title: str,
     selections: Sequence[str],
+    *,
     columns: int = 4,
     caption: str = "",
     box_style: box.Box = box.SIMPLE,
@@ -126,19 +129,19 @@ def render_selection_indexed_table(
 ) -> Table:
     """Create a selection table with the given parameters."""
     table = render_table_base(
-        title,
-        caption,
-        columns,
-        box_style,
-        show_lines,
-        show_header,
-        show_footer,
-        style,
-        header_style,
-        footer_style,
-        title_style,
-        caption_style,
-        highlight,
+        title=title,
+        caption=caption,
+        columns=columns,
+        box_style=box_style,
+        show_lines=show_lines,
+        show_header=show_header,
+        show_footer=show_footer,
+        style=style,
+        header_style=header_style,
+        footer_style=footer_style,
+        title_style=title_style,
+        caption_style=caption_style,
+        highlight=highlight,
     )
 
     for indexes, chunk in zip(
@@ -156,6 +159,7 @@ def render_selection_indexed_table(
 def render_selection_dict_table(
     title: str,
     selections: dict[str, SelectionOption],
+    *,
     columns: int = 2,
     caption: str = "",
     box_style: box.Box = box.SIMPLE,
@@ -171,19 +175,19 @@ def render_selection_dict_table(
 ) -> Table:
     """Create a selection table with the given parameters."""
     table = render_table_base(
-        title,
-        caption,
-        columns,
-        box_style,
-        show_lines,
-        show_header,
-        show_footer,
-        style,
-        header_style,
-        footer_style,
-        title_style,
-        caption_style,
-        highlight,
+        title=title,
+        caption=caption,
+        columns=columns,
+        box_style=box_style,
+        show_lines=show_lines,
+        show_header=show_header,
+        show_footer=show_footer,
+        style=style,
+        header_style=header_style,
+        footer_style=footer_style,
+        title_style=title_style,
+        caption_style=caption_style,
+        highlight=highlight,
     )
 
     for chunk in chunks(selections.items(), columns):
@@ -200,6 +204,7 @@ def render_selection_dict_table(
 async def prompt_for_index(
     max_index: int,
     table: Table,
+    *,
     min_index: int = 0,
     default_selection: str = "",
     console: Console | None = None,
@@ -224,6 +229,7 @@ async def prompt_for_index(
 async def prompt_for_selection(
     keys: Sequence[str] | KeysView[str],
     table: Table,
+    *,
     default_selection: str = "",
     console: Console | None = None,
     prompt_session: PromptSession | None = None,
@@ -249,6 +255,7 @@ async def prompt_for_selection(
 async def select_value_from_list(
     title: str,
     selections: Sequence[str],
+    *,
     console: Console | None = None,
     prompt_session: PromptSession | None = None,
     prompt_message: str = "Select an option > ",
@@ -268,20 +275,20 @@ async def select_value_from_list(
 ):
     """Prompt for a selection. Return the selected item."""
     table = render_selection_indexed_table(
-        title,
-        selections,
-        columns,
-        caption,
-        box_style,
-        show_lines,
-        show_header,
-        show_footer,
-        style,
-        header_style,
-        footer_style,
-        title_style,
-        caption_style,
-        highlight,
+        title=title,
+        selections=selections,
+        columns=columns,
+        caption=caption,
+        box_style=box_style,
+        show_lines=show_lines,
+        show_header=show_header,
+        show_footer=show_footer,
+        style=style,
+        header_style=header_style,
+        footer_style=footer_style,
+        title_style=title_style,
+        caption_style=caption_style,
+        highlight=highlight,
     )
     prompt_session = prompt_session or PromptSession()
     console = console or Console(color_system="auto")
@@ -301,6 +308,7 @@ async def select_value_from_list(
 async def select_key_from_dict(
     selections: dict[str, SelectionOption],
     table: Table,
+    *,
     console: Console | None = None,
     prompt_session: PromptSession | None = None,
     prompt_message: str = "Select an option > ",
@@ -325,6 +333,7 @@ async def select_key_from_dict(
 async def select_value_from_dict(
     selections: dict[str, SelectionOption],
     table: Table,
+    *,
     console: Console | None = None,
     prompt_session: PromptSession | None = None,
     prompt_message: str = "Select an option > ",
@@ -351,6 +360,7 @@ async def select_value_from_dict(
 async def get_selection_from_dict_menu(
     title: str,
     selections: dict[str, SelectionOption],
+    *,
     console: Console | None = None,
     prompt_session: PromptSession | None = None,
     prompt_message: str = "Select an option > ",
@@ -363,10 +373,10 @@ async def get_selection_from_dict_menu(
     )
 
     return await select_value_from_dict(
-        selections,
-        table,
-        console,
-        prompt_session,
-        prompt_message,
-        default_selection,
+        selections=selections,
+        table=table,
+        console=console,
+        prompt_session=prompt_session,
+        prompt_message=prompt_message,
+        default_selection=default_selection,
     )

{falyx-0.1.20 → falyx-0.1.22}/falyx/selection_action.py

@@ -1,6 +1,5 @@
 # Falyx CLI Framework — (c) 2025 rtj.dev LLC — MIT Licensed
 """selection_action.py"""
-from pathlib import Path
 from typing import Any
 
 from prompt_toolkit import PromptSession
@@ -117,7 +116,9 @@ class SelectionAction(BaseAction):
             await self.hooks.trigger(HookType.BEFORE, context)
             if isinstance(self.selections, list):
                 table = render_selection_indexed_table(
-                    self.title, self.selections, self.columns
+                    title=self.title,
+                    selections=self.selections,
+                    columns=self.columns,
                 )
                 if not self.never_prompt:
                     index = await prompt_for_index(
@@ -134,7 +135,7 @@ class SelectionAction(BaseAction):
                 result = self.selections[int(index)]
             elif isinstance(self.selections, dict):
                 table = render_selection_dict_table(
-                    self.title, self.selections, self.columns
+                    title=self.title, selections=self.selections, columns=self.columns
                 )
                 if not self.never_prompt:
                     key = await prompt_for_selection(

falyx-0.1.22/falyx/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.22"

{falyx-0.1.20 → falyx-0.1.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "falyx"
-version = "0.1.20"
+version = "0.1.22"
 description = "Reliable and introspectable async CLI action framework."
 authors = ["Roland Thomas Jr <roland@rtj.dev>"]
 license = "MIT"

falyx-0.1.20/falyx/select_files_action.py

@@ -1,68 +0,0 @@
-
-class SelectFilesAction(BaseAction):
-    def __init__(
-        self,
-        name: str,
-        directory: Path | str = ".",
-        title: str = "Select a file",
-        prompt_message: str = "Choose > ",
-        style: str = OneColors.WHITE,
-        suffix_filter: str | None = None,
-        return_path: bool = True,
-        console: Console | None = None,
-        prompt_session: PromptSession | None = None,
-    ):
-        super().__init__(name)
-        self.directory = Path(directory).resolve()
-        self.title = title
-        self.prompt_message = prompt_message
-        self.suffix_filter = suffix_filter
-        self.style = style
-        self.return_path = return_path
-        self.console = console or Console()
-        self.prompt_session = prompt_session or PromptSession()
-
-    async def _run(self, *args, **kwargs) -> Any:
-        context = ExecutionContext(name=self.name, args=args, kwargs=kwargs, action=self)
-        context.start_timer()
-        try:
-            await self.hooks.trigger(HookType.BEFORE, context)
-
-            files = [
-                f
-                for f in self.directory.iterdir()
-                if f.is_file()
-                and (self.suffix_filter is None or f.suffix == self.suffix_filter)
-            ]
-            if not files:
-                raise FileNotFoundError("No files found in directory.")
-
-            options = {
-                str(i): SelectionOption(
-                    f.name, f if self.return_path else f.read_text(), self.style
-                )
-                for i, f in enumerate(files)
-            }
-            table = render_selection_dict_table(self.title, options)
-
-            key = await prompt_for_selection(
-                options.keys(),
-                table,
-                console=self.console,
-                prompt_session=self.prompt_session,
-                prompt_message=self.prompt_message,
-            )
-
-            result = options[key].value
-            context.result = result
-            await self.hooks.trigger(HookType.ON_SUCCESS, context)
-            return result
-        except Exception as error:
-            context.exception = error
-            await self.hooks.trigger(HookType.ON_ERROR, context)
-            raise
-        finally:
-            context.stop_timer()
-            await self.hooks.trigger(HookType.AFTER, context)
-            await self.hooks.trigger(HookType.ON_TEARDOWN, context)
-            er.record(context)

falyx-0.1.20/falyx/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.20"