falyx 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

falyx/__main__.py

@@ -6,6 +6,7 @@ Licensed under the MIT License. See LICENSE file for details.
 """
 
 import asyncio
+import os
 import sys
 from argparse import Namespace
 from pathlib import Path
@@ -22,6 +23,7 @@ def find_falyx_config() -> Path | None:
         Path.cwd() / "falyx.toml",
         Path.cwd() / ".falyx.yaml",
         Path.cwd() / ".falyx.toml",
+        Path(os.environ.get("FALYX_CONFIG", "falyx.yaml")),
         Path.home() / ".config" / "falyx" / "falyx.yaml",
         Path.home() / ".config" / "falyx" / "falyx.toml",
         Path.home() / ".falyx.yaml",
@@ -67,12 +69,7 @@ def run(args: Namespace) -> Any:
         print("No Falyx config file found. Exiting.")
         return None
 
-    flx = Falyx(
-        title="🛠️ Config-Driven CLI",
-        cli_args=args,
-        columns=4,
-    )
-    flx.add_commands(loader(bootstrap_path))
+    flx: Falyx = loader(bootstrap_path)
     return asyncio.run(flx.run())
 
 

falyx/action_factory.py

@@ -1,3 +1,4 @@
+# Falyx CLI Framework — (c) 2025 rtj.dev LLC — MIT Licensed
 from typing import Any
 
 from rich.tree import Tree

falyx/command.py

@@ -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/config.py

@@ -1,17 +1,26 @@
 # Falyx CLI Framework — (c) 2025 rtj.dev LLC — MIT Licensed
 """config.py
 Configuration loader for Falyx CLI commands."""
+from __future__ import annotations
 
 import importlib
+import sys
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 
 import toml
 import yaml
+from pydantic import BaseModel, Field, field_validator, model_validator
+from rich.console import Console
 
 from falyx.action import Action, BaseAction
 from falyx.command import Command
+from falyx.falyx import Falyx
 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:
@@ -21,8 +30,8 @@ def wrap_if_needed(obj: Any, name=None) -> BaseAction | Command:
         return Action(name=name or getattr(obj, "__name__", "unnamed"), action=obj)
     else:
         raise TypeError(
-            f"Cannot wrap object of type '{type(obj).__name__}' as a BaseAction or Command. "
-            "It must be a callable or an instance of BaseAction."
+            f"Cannot wrap object of type '{type(obj).__name__}'. "
+            "Expected a function or BaseAction."
         )
 
 
@@ -30,12 +39,125 @@ 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
+
+
+class RawCommand(BaseModel):
+    key: str
+    description: str
+    action: str
+
+    args: tuple[Any, ...] = ()
+    kwargs: dict[str, Any] = {}
+    aliases: list[str] = []
+    tags: list[str] = []
+    style: str = "white"
+
+    confirm: bool = False
+    confirm_message: str = "Are you sure?"
+    preview_before_confirm: bool = True
+
+    spinner: bool = False
+    spinner_message: str = "Processing..."
+    spinner_type: str = "dots"
+    spinner_style: str = "cyan"
+    spinner_kwargs: dict[str, Any] = {}
+
+    before_hooks: list[Callable] = []
+    success_hooks: list[Callable] = []
+    error_hooks: list[Callable] = []
+    after_hooks: list[Callable] = []
+    teardown_hooks: list[Callable] = []
+
+    logging_hooks: bool = False
+    retry: bool = False
+    retry_all: bool = False
+    retry_policy: RetryPolicy = Field(default_factory=RetryPolicy)
+    requires_input: bool | None = None
+    hidden: bool = False
+    help_text: str = ""
+
+    @field_validator("retry_policy")
+    @classmethod
+    def validate_retry_policy(cls, value: dict | RetryPolicy) -> RetryPolicy:
+        if isinstance(value, RetryPolicy):
+            return value
+        if not isinstance(value, dict):
+            raise ValueError("retry_policy must be a dictionary.")
+        return RetryPolicy(**value)
+
+
+def convert_commands(raw_commands: list[dict[str, Any]]) -> list[Command]:
+    commands = []
+    for entry in raw_commands:
+        raw_command = RawCommand(**entry)
+        commands.append(
+            Command.model_validate(
+                {
+                    **raw_command.model_dump(exclude={"action"}),
+                    "action": wrap_if_needed(
+                        import_action(raw_command.action), name=raw_command.description
+                    ),
+                }
+            )
+        )
+    return commands
 
 
-def loader(file_path: Path | str) -> list[dict[str, Any]]:
+class FalyxConfig(BaseModel):
+    title: str = "Falyx CLI"
+    prompt: str | list[tuple[str, str]] | list[list[str]] = [
+        (OneColors.BLUE_b, "FALYX > ")
+    ]
+    columns: int = 4
+    welcome_message: str = ""
+    exit_message: str = ""
+    commands: list[Command] | list[dict] = []
+
+    @model_validator(mode="after")
+    def validate_prompt_format(self) -> FalyxConfig:
+        if isinstance(self.prompt, list):
+            for pair in self.prompt:
+                if not isinstance(pair, (list, tuple)) or len(pair) != 2:
+                    raise ValueError(
+                        "Prompt list must contain 2-element (style, text) pairs"
+                    )
+        return self
+
+    def to_falyx(self) -> Falyx:
+        flx = Falyx(
+            title=self.title,
+            prompt=self.prompt,
+            columns=self.columns,
+            welcome_message=self.welcome_message,
+            exit_message=self.exit_message,
+        )
+        flx.add_commands(self.commands)
+        return flx
+
+
+def loader(file_path: Path | str) -> Falyx:
     """
     Load command definitions from a YAML or TOML file.
 
@@ -48,15 +170,13 @@ def loader(file_path: Path | str) -> list[dict[str, Any]]:
         file_path (str): Path to the config file (YAML or TOML).
 
     Returns:
-        list[dict[str, Any]]: A list of command configuration dictionaries.
+        Falyx: An instance of the Falyx CLI with loaded commands.
 
     Raises:
         ValueError: If the file format is unsupported or file cannot be parsed.
     """
-    if isinstance(file_path, str):
+    if isinstance(file_path, (str, Path)):
         path = Path(file_path)
-    elif isinstance(file_path, Path):
-        path = file_path
     else:
         raise TypeError("file_path must be a string or Path object.")
 
@@ -72,48 +192,23 @@ def loader(file_path: Path | str) -> list[dict[str, Any]]:
         else:
             raise ValueError(f"Unsupported config format: {suffix}")
 
-    if not isinstance(raw_config, list):
-        raise ValueError("Configuration file must contain a list of command definitions.")
-
-    required = ["key", "description", "action"]
-    commands = []
-    for entry in raw_config:
-        for field in required:
-            if field not in entry:
-                raise ValueError(f"Missing '{field}' in command entry: {entry}")
-
-        command_dict = {
-            "key": entry["key"],
-            "description": entry["description"],
-            "action": wrap_if_needed(
-                import_action(entry["action"]), name=entry["description"]
-            ),
-            "args": tuple(entry.get("args", ())),
-            "kwargs": entry.get("kwargs", {}),
-            "hidden": entry.get("hidden", False),
-            "aliases": entry.get("aliases", []),
-            "help_text": entry.get("help_text", ""),
-            "style": entry.get("style", "white"),
-            "confirm": entry.get("confirm", False),
-            "confirm_message": entry.get("confirm_message", "Are you sure?"),
-            "preview_before_confirm": entry.get("preview_before_confirm", True),
-            "spinner": entry.get("spinner", False),
-            "spinner_message": entry.get("spinner_message", "Processing..."),
-            "spinner_type": entry.get("spinner_type", "dots"),
-            "spinner_style": entry.get("spinner_style", "cyan"),
-            "spinner_kwargs": entry.get("spinner_kwargs", {}),
-            "before_hooks": entry.get("before_hooks", []),
-            "success_hooks": entry.get("success_hooks", []),
-            "error_hooks": entry.get("error_hooks", []),
-            "after_hooks": entry.get("after_hooks", []),
-            "teardown_hooks": entry.get("teardown_hooks", []),
-            "retry": entry.get("retry", False),
-            "retry_all": entry.get("retry_all", False),
-            "retry_policy": RetryPolicy(**entry.get("retry_policy", {})),
-            "tags": entry.get("tags", []),
-            "logging_hooks": entry.get("logging_hooks", False),
-            "requires_input": entry.get("requires_input", None),
-        }
-        commands.append(command_dict)
+    if not isinstance(raw_config, dict):
+        raise ValueError(
+            "Configuration file must contain a dictionary with a list of commands.\n"
+            "Example:\n"
+            "title: 'My CLI'\n"
+            "commands:\n"
+            "  - key: 'a'\n"
+            "    description: 'Example command'\n"
+            "    action: 'my_module.my_function'"
+        )
 
-    return commands
+    commands = convert_commands(raw_config["commands"])
+    return FalyxConfig(
+        title=raw_config.get("title", f"[{OneColors.BLUE_b}]Falyx CLI"),
+        prompt=raw_config.get("prompt", [(OneColors.BLUE_b, "FALYX > ")]),
+        columns=raw_config.get("columns", 4),
+        welcome_message=raw_config.get("welcome_message", ""),
+        exit_message=raw_config.get("exit_message", ""),
+        commands=commands,
+    ).to_falyx()

falyx/config_schema.py

@@ -0,0 +1,76 @@
+FALYX_CONFIG_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Falyx CLI Config",
+    "type": "object",
+    "properties": {
+        "title": {"type": "string", "description": "Title shown at top of menu"},
+        "prompt": {
+            "oneOf": [
+                {"type": "string"},
+                {
+                    "type": "array",
+                    "items": {
+                        "type": "array",
+                        "prefixItems": [
+                            {
+                                "type": "string",
+                                "description": "Style string (e.g., 'bold #ff0000 italic')",
+                            },
+                            {"type": "string", "description": "Text content"},
+                        ],
+                        "minItems": 2,
+                        "maxItems": 2,
+                    },
+                },
+            ]
+        },
+        "columns": {
+            "type": "integer",
+            "minimum": 1,
+            "description": "Number of menu columns",
+        },
+        "welcome_message": {"type": "string"},
+        "exit_message": {"type": "string"},
+        "commands": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["key", "description", "action"],
+                "properties": {
+                    "key": {"type": "string", "minLength": 1},
+                    "description": {"type": "string"},
+                    "action": {
+                        "type": "string",
+                        "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*(\\.[a-zA-Z_][a-zA-Z0-9_]*)+$",
+                        "description": "Dotted import path (e.g., mymodule.task)",
+                    },
+                    "args": {"type": "array"},
+                    "kwargs": {"type": "object"},
+                    "aliases": {"type": "array", "items": {"type": "string"}},
+                    "tags": {"type": "array", "items": {"type": "string"}},
+                    "style": {"type": "string"},
+                    "confirm": {"type": "boolean"},
+                    "confirm_message": {"type": "string"},
+                    "preview_before_confirm": {"type": "boolean"},
+                    "spinner": {"type": "boolean"},
+                    "spinner_message": {"type": "string"},
+                    "spinner_type": {"type": "string"},
+                    "spinner_style": {"type": "string"},
+                    "logging_hooks": {"type": "boolean"},
+                    "retry": {"type": "boolean"},
+                    "retry_all": {"type": "boolean"},
+                    "retry_policy": {
+                        "type": "object",
+                        "properties": {
+                            "enabled": {"type": "boolean"},
+                            "max_retries": {"type": "integer"},
+                            "delay": {"type": "number"},
+                            "backoff": {"type": "number"},
+                        },
+                    },
+                },
+            },
+        },
+    },
+    "required": ["commands"],
+}

falyx/execution_registry.py

@@ -9,6 +9,7 @@ from rich.console import Console
 from rich.table import Table
 
 from falyx.context import ExecutionContext
+from falyx.themes.colors import OneColors
 from falyx.utils import logger
 
 
@@ -66,10 +67,10 @@ class ExecutionRegistry:
             duration = f"{ctx.duration:.3f}s" if ctx.duration else "n/a"
 
             if ctx.exception:
-                status = "[bold red]❌ Error"
+                status = f"[{OneColors.DARK_RED}]❌ Error"
                 result = repr(ctx.exception)
             else:
-                status = "[green]✅ Success"
+                status = f"[{OneColors.GREEN}]✅ Success"
                 result = repr(ctx.result)
                 if len(result) > 1000:
                     result = f"{result[:1000]}..."

falyx/falyx.py

@@ -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",
             )
 
@@ -291,7 +291,7 @@ class Falyx:
         """Returns the help command for the menu."""
         return Command(
             key="H",
-            aliases=["HELP"],
+            aliases=["HELP", "?"],
             description="Help",
             action=self._show_help,
             style=OneColors.LIGHT_YELLOW,
@@ -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(
@@ -558,10 +560,24 @@ class Falyx:
         self.add_command(key, description, submenu.menu, style=style)
         submenu.update_exit_command(key="B", description="Back", aliases=["BACK"])
 
-    def add_commands(self, commands: list[dict]) -> None:
-        """Adds multiple commands to the menu."""
+    def add_commands(self, commands: list[Command] | list[dict]) -> None:
+        """Adds a list of Command instances or config dicts."""
         for command in commands:
-            self.add_command(**command)
+            if isinstance(command, dict):
+                self.add_command(**command)
+            elif isinstance(command, Command):
+                self.add_command_from_command(command)
+            else:
+                raise FalyxError(
+                    "Command must be a dictionary or an instance of Command."
+                )
+
+    def add_command_from_command(self, command: Command) -> None:
+        """Adds a command to the menu from an existing Command object."""
+        if not isinstance(command, Command):
+            raise FalyxError("command must be an instance of Command.")
+        self._validate_command_key(command.key)
+        self.commands[command.key] = command
 
     def add_command(
         self,
@@ -694,6 +710,16 @@ 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 and self.help_command:
+            is_preview = False
+            choice = "?"
+        elif 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
 
@@ -788,12 +814,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,
@@ -877,28 +908,29 @@ class Falyx:
         self.debug_hooks()
         if self.welcome_message:
             self.print_message(self.welcome_message)
-        while True:
-            if callable(self.render_menu):
-                self.render_menu(self)
-            else:
-                self.console.print(self.table, justify="center")
-            try:
-                task = asyncio.create_task(self.process_command())
-                should_continue = await task
-                if not should_continue:
+        try:
+            while True:
+                if callable(self.render_menu):
+                    self.render_menu(self)
+                else:
+                    self.console.print(self.table, justify="center")
+                try:
+                    task = asyncio.create_task(self.process_command())
+                    should_continue = await task
+                    if not should_continue:
+                        break
+                except (EOFError, KeyboardInterrupt):
+                    logger.info("EOF or KeyboardInterrupt. Exiting menu.")
                     break
-            except (EOFError, KeyboardInterrupt):
-                logger.info("EOF or KeyboardInterrupt. Exiting menu.")
-                break
-            except QuitSignal:
-                logger.info("QuitSignal received. Exiting menu.")
-                break
-            except BackSignal:
-                logger.info("BackSignal received.")
-            finally:
-                logger.info(f"Exiting menu: {self.get_title()}")
-                if self.exit_message:
-                    self.print_message(self.exit_message)
+                except QuitSignal:
+                    logger.info("QuitSignal received. Exiting menu.")
+                    break
+                except BackSignal:
+                    logger.info("BackSignal received.")
+        finally:
+            logger.info(f"Exiting menu: {self.get_title()}")
+            if self.exit_message:
+                self.print_message(self.exit_message)
 
     async def run(self) -> None:
         """Run Falyx CLI with structured subcommands."""
@@ -943,11 +975,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:
@@ -955,6 +990,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":
@@ -976,6 +1014,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()