framework-m-core 0.4.1__py3-none-any.whl

framework_m_core/__init__.py

@@ -0,0 +1,29 @@
+"""Core module - Domain logic and interfaces."""
+
+import importlib.metadata
+
+from framework_m_core.container import Container
+from framework_m_core.domain.base_doctype import BaseDocType as DocType
+from framework_m_core.domain.base_doctype import Field
+from framework_m_core.interfaces.base_doctype import BaseDocTypeProtocol
+from framework_m_core.interfaces.bootstrap import BootstrapProtocol
+from framework_m_core.interfaces.controller import BaseControllerProtocol
+from framework_m_core.interfaces.schema_mapper import SchemaMapperProtocol
+from framework_m_core.registry import MetaRegistry
+
+try:
+    __version__ = importlib.metadata.version("framework-m-core")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "0.0.0"
+
+__all__ = [
+    "BaseControllerProtocol",
+    "BaseDocTypeProtocol",
+    "BootstrapProtocol",
+    "Container",
+    "DocType",
+    "Field",
+    "MetaRegistry",
+    "SchemaMapperProtocol",
+    "__version__",
+]

framework_m_core/cli/config.py

@@ -0,0 +1,128 @@
+"""Configuration Management CLI Commands.
+
+This module provides CLI commands for managing Framework M configuration:
+- m config:show: Display current configuration
+- m config:set <key> <value>: Update configuration value
+
+Usage:
+    m config:show                 # Show all config
+    m config:set framework.name myapp
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Any
+
+import cyclopts
+
+from framework_m_core.config import (
+    CONFIG_FILE_NAME,
+    DEFAULT_CONFIG,
+    find_config_file,
+    format_config,
+    get_nested_value,
+    load_config,
+    save_config,
+    set_nested_value,
+)
+
+# =============================================================================
+# CLI Commands
+# =============================================================================
+
+
+def config_show_command(
+    key: Annotated[
+        str | None,
+        cyclopts.Parameter(help="Specific key to show (e.g., framework.name)"),
+    ] = None,
+    config_file: Annotated[
+        Path | None,
+        cyclopts.Parameter(name="--config", help="Path to config file"),
+    ] = None,
+) -> None:
+    """Display current configuration.
+
+    Shows the current Framework M configuration from framework_config.toml.
+
+    Examples:
+        m config:show                    # Show all config
+        m config:show framework.name     # Show specific key
+    """
+    config_path = config_file or find_config_file()
+    config = load_config(config_path)
+
+    if not config:
+        print(f"No config found at: {config_path}")
+        print()
+        print("Create a config file with default values:")
+        print("  m config:set framework.name myapp")
+        return
+
+    print(f"Config file: {config_path}")
+    print()
+
+    if key:
+        value = get_nested_value(config, key)
+        if value is not None:
+            print(f"{key} = {value}")
+        else:
+            print(f"Key not found: {key}")
+            raise SystemExit(1)
+    else:
+        print(format_config(config))
+
+
+def config_set_command(
+    key: Annotated[str, cyclopts.Parameter(help="Key to set (e.g., framework.name)")],
+    value: Annotated[str, cyclopts.Parameter(help="Value to set")],
+    config_file: Annotated[
+        Path | None,
+        cyclopts.Parameter(name="--config", help="Path to config file"),
+    ] = None,
+) -> None:
+    """Set a configuration value.
+
+    Updates a value in framework_config.toml, creating the file if needed.
+
+    Examples:
+        m config:set framework.name myapp
+        m config:set apps.installed "myapp,otherapp"
+    """
+    config_path = config_file or find_config_file()
+    config = load_config(config_path) or DEFAULT_CONFIG.copy()
+
+    # Parse value (handle lists)
+    if "," in value:
+        parsed_value: Any = [v.strip() for v in value.split(",")]
+    else:
+        parsed_value = value
+
+    old_value = get_nested_value(config, key)
+    set_nested_value(config, key, parsed_value)
+
+    save_config(config_path, config)
+
+    print(f"Config file: {config_path}")
+    print()
+    if old_value is not None:
+        print(f"  {key}: {old_value} -> {parsed_value}")
+    else:
+        print(f"  {key} = {parsed_value}")
+    print()
+    print("✓ Configuration updated")
+
+
+__all__ = [
+    "CONFIG_FILE_NAME",
+    "DEFAULT_CONFIG",
+    "config_set_command",
+    "config_show_command",
+    "find_config_file",
+    "format_config",
+    "get_nested_value",
+    "load_config",
+    "save_config",
+    "set_nested_value",
+]

framework_m_core/cli/main.py

@@ -0,0 +1,30 @@
+import cyclopts
+
+from framework_m_core import __version__
+from framework_m_core.cli.config import config_set_command, config_show_command
+from framework_m_core.cli.plugin_loader import load_plugins
+from framework_m_core.cli.utility import info_command
+
+app = cyclopts.App(
+    name="m",
+    version=__version__,
+    help="Framework M CLI",
+)
+
+# Register core commands
+app.command(info_command, name="info")
+
+# Config commands
+app.command(config_show_command, name="config:show")
+app.command(config_set_command, name="config:set")
+
+# Load plugins
+load_plugins(app)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

framework_m_core/cli/plugin_loader.py

@@ -0,0 +1,132 @@
+"""Plugin loader for CLI extensibility.
+
+This module provides the mechanism for 3rd-party apps to register
+CLI commands via entry points. Apps can register either cyclopts Apps
+(sub-command groups) or standalone functions as commands.
+
+Entry Point Group: framework_m_core.cli_commands
+
+Example pyproject.toml:
+    [project.entry-points."framework_m_core.cli_commands"]
+    studio = "my_app.cli:studio_app"      # cyclopts.App
+    custom = "my_app.cli:custom_command"  # Function
+
+Example:
+    >>> app = cyclopts.App()
+    >>> load_plugins(app)  # Discovers and registers all plugins
+"""
+
+from __future__ import annotations
+
+import logging
+from importlib.metadata import entry_points
+from typing import TYPE_CHECKING
+
+import cyclopts
+
+if TYPE_CHECKING:
+    from importlib.metadata import EntryPoint
+
+logger = logging.getLogger(__name__)
+
+# Entry point group for CLI command plugins
+CLI_COMMANDS_GROUP = "framework_m_core.cli_commands"
+
+
+def discover_plugins() -> list[EntryPoint]:
+    """Discover all registered CLI command plugins.
+
+    Scans the entry points registered under the 'framework_m_core.cli_commands'
+    group. Each entry point should point to either:
+    - A `cyclopts.App` instance (registered as sub-command group)
+    - A callable function (registered as single command)
+
+    Returns:
+        List of entry points for CLI plugins.
+
+    Example:
+        >>> plugins = discover_plugins()
+        >>> for ep in plugins:
+        ...     print(f"Found plugin: {ep.name}")
+    """
+    eps = entry_points()
+
+    # Python 3.12+ uses .select()
+    return list(eps.select(group=CLI_COMMANDS_GROUP))
+
+
+def register_plugins(app: cyclopts.App, plugins: list[EntryPoint]) -> None:
+    """Register discovered plugins with the main cyclopts app.
+
+    For each plugin entry point:
+    - If it's a cyclopts.App: register as sub-command group
+    - If it's a callable: register as standalone command
+
+    Args:
+        app: The main cyclopts application instance.
+        plugins: List of entry points to register.
+
+    Example:
+        >>> app = cyclopts.App()
+        >>> plugins = discover_plugins()
+        >>> register_plugins(app, plugins)
+    """
+    for ep in plugins:
+        try:
+            plugin = ep.load()
+        except Exception as e:
+            logger.warning(
+                f"Failed to load CLI plugin '{ep.name}': {e}",
+                exc_info=True,
+            )
+            continue
+
+        try:
+            if isinstance(plugin, cyclopts.App):
+                # Register cyclopts App as sub-command group
+                app.command(plugin, name=ep.name)
+                logger.debug(f"Registered cyclopts App plugin: {ep.name}")
+            elif callable(plugin):
+                # Register function as command
+                app.command(plugin, name=ep.name)
+                logger.debug(f"Registered function plugin: {ep.name}")
+            else:
+                logger.warning(
+                    f"Plugin '{ep.name}' is not a cyclopts App or callable, skipping"
+                )
+        except Exception as e:
+            logger.warning(
+                f"Failed to register CLI plugin '{ep.name}': {e}",
+                exc_info=True,
+            )
+
+
+def load_plugins(app: cyclopts.App) -> None:
+    """Discover and register all CLI plugins.
+
+    Convenience function that combines discovery and registration.
+    Call this during app initialization to enable all plugins.
+
+    Args:
+        app: The main cyclopts application instance.
+
+    Example:
+        >>> app = cyclopts.App(name="m")
+        >>> load_plugins(app)  # All plugins now registered
+        >>> app()  # Run CLI
+    """
+    plugins = discover_plugins()
+
+    if plugins:
+        logger.info(f"Discovered {len(plugins)} CLI plugin(s)")
+        register_plugins(app, plugins)
+    else:
+        logger.debug("No CLI plugins discovered")
+
+
+__all__ = [
+    "CLI_COMMANDS_GROUP",
+    "discover_plugins",
+    "load_plugins",
+    "register_plugins",
+]

framework_m_core/cli/utility.py

@@ -0,0 +1,58 @@
+"""Utility commands for Framework M CLI."""
+
+from __future__ import annotations
+
+import platform
+import sys
+from typing import Annotated
+
+import cyclopts
+from rich.console import Console
+from rich.table import Table
+
+from framework_m_core import __version__
+
+console = Console()
+
+
+def get_python_version() -> str:
+    """Get Python version string."""
+    return platform.python_version()
+
+
+def get_framework_version() -> str:
+    """Get Framework M version string."""
+    return __version__
+
+
+def get_pythonpath() -> str:
+    """Get PYTHONPATH."""
+    return sys.path[0]
+
+
+def info_command(
+    verbose: Annotated[
+        bool, cyclopts.Parameter(name="--verbose", help="Show detailed info")
+    ] = False,
+) -> None:
+    """Show system and framework information."""
+    table = Table(title="Framework M Information")
+    table.add_column("Key", style="cyan")
+    table.add_column("Value", style="green")
+
+    table.add_row("Framework M", get_framework_version())
+    table.add_row("Python", get_python_version())
+
+    if verbose:
+        table.add_row("Platform", platform.platform())
+        table.add_row("Services", "None (Mock)")
+
+    console.print(table)
+
+
+__all__ = [
+    "get_framework_version",
+    "get_python_version",
+    "get_pythonpath",
+    "info_command",
+]

framework_m_core/config.py

@@ -0,0 +1,171 @@
+"""Core Configuration Management.
+
+This module provides utilities for finding and loading the framework configuration.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+# Default config file name
+CONFIG_FILE_NAME = "framework_config.toml"
+
+# Default config structure
+DEFAULT_CONFIG = {
+    "framework": {
+        "name": "my_app",
+        "version": "0.1.0",
+    },
+    "apps": {
+        "installed": [],
+    },
+}
+
+
+def find_config_file() -> Path:
+    """Find the config file in current directory or parents.
+
+    Returns:
+        Path to config file (may not exist)
+    """
+    for path in [Path.cwd(), *Path.cwd().parents]:
+        config_path = path / CONFIG_FILE_NAME
+        if config_path.exists():
+            return config_path
+
+    # Default to cwd if not found
+    return Path.cwd() / CONFIG_FILE_NAME
+
+
+def load_config(config_path: Path | None = None) -> dict[str, Any]:
+    """Load configuration from TOML file.
+
+    Args:
+        config_path: Path to config file (auto-detect if None)
+
+    Returns:
+        Configuration dict
+    """
+    if config_path is None:
+        config_path = find_config_file()
+
+    if not config_path.exists():
+        return {}
+
+    try:
+        import tomllib
+
+        return tomllib.loads(config_path.read_text())
+    except Exception:
+        return {}
+
+
+def get_nested_value(config: dict[str, Any], key: str) -> Any | None:
+    """Get a nested value from config using dot notation.
+
+    Args:
+        config: Configuration dict
+        key: Dot-separated key (e.g., "framework.name")
+
+    Returns:
+        Value or None if not found
+    """
+    parts = key.split(".")
+    current = config
+
+    for part in parts:
+        if isinstance(current, dict) and part in current:
+            current = current[part]
+        else:
+            return None
+
+    return current
+
+
+def set_nested_value(config: dict[str, Any], key: str, value: Any) -> None:
+    """Set a nested value in config using dot notation.
+
+    Args:
+        config: Configuration dict to modify
+        key: Dot-separated key (e.g., "framework.name")
+        value: Value to set
+    """
+    parts = key.split(".")
+    current = config
+
+    # Navigate/create nested dicts
+    for part in parts[:-1]:
+        if part not in current:
+            current[part] = {}
+        current = current[part]
+
+    # Set the final value
+    current[parts[-1]] = value
+
+
+def save_config(config_path: Path, config: dict[str, Any]) -> None:
+    """Save configuration to TOML file.
+
+    Args:
+        config_path: Path to config file
+        config: Configuration dict to save
+    """
+    # Simple TOML writing (no external dependencies)
+    lines: list[str] = []
+    for section, values in config.items():
+        lines.append(f"[{section}]")
+        if isinstance(values, dict):
+            for key, value in values.items():
+                if isinstance(value, str):
+                    lines.append(f'{key} = "{value}"')
+                elif isinstance(value, list):
+                    items = ", ".join(f'"{v}"' for v in value)
+                    lines.append(f"{key} = [{items}]")
+                elif isinstance(value, bool):
+                    lines.append(f"{key} = {str(value).lower()}")
+                elif isinstance(value, (int, float)):
+                    lines.append(f"{key} = {value}")
+                else:
+                    lines.append(f'{key} = "{value}"')
+        lines.append("")
+
+    config_path.write_text("\n".join(lines))
+
+
+def format_config(config: dict[str, Any], indent: int = 0) -> str:
+    """Format config dict for display.
+
+    Args:
+        config: Configuration dict
+        indent: Indentation level
+
+    Returns:
+        Formatted string
+    """
+    lines = []
+    prefix = "  " * indent
+
+    for key, value in config.items():
+        if isinstance(value, dict):
+            lines.append(f"{prefix}[{key}]")
+            lines.append(format_config(value, indent + 1))
+        elif isinstance(value, list):
+            items = ", ".join(str(v) for v in value)
+            lines.append(f"{prefix}{key} = [{items}]")
+        else:
+            lines.append(f"{prefix}{key} = {value}")
+
+    return "\n".join(lines)
+
+
+__all__ = [
+    "CONFIG_FILE_NAME",
+    "DEFAULT_CONFIG",
+    "find_config_file",
+    "format_config",
+    "get_nested_value",
+    "load_config",
+    "save_config",
+    "set_nested_value",
+]