mcli-framework 7.8.5__py3-none-any.whl → 7.9.0__py3-none-any.whl

mcli/app/main.py

@@ -344,6 +344,15 @@ def _add_lazy_commands(app: click.Group):
     except Exception as e:
         logger.debug(f"Could not load self commands: {e}")
 
+    # Library utilities and secrets management
+    try:
+        from mcli.lib.lib import lib
+
+        app.add_command(lib, name="lib")
+        logger.debug("Added lib commands")
+    except Exception as e:
+        logger.debug(f"Could not load lib commands: {e}")
+
     # Add workflow with completion-aware lazy loading
     try:
         from mcli.app.completion_helpers import create_completion_aware_lazy_group

mcli/lib/lib.py

@@ -3,6 +3,8 @@ import sys
 
 import click
 
+from mcli.lib.secrets.commands import secrets_group
+
 
 def import_public_module(module_name: str):
     prefix = "mcli.public."
@@ -20,10 +22,15 @@ def import_public_module(module_name: str):
     return module
 
 
-@click.group(name="lib")
+@click.group(name="lib", help="Library utilities and secrets management")
 def lib():
+    """Library utilities and management commands."""
     pass
 
 
+# Add secrets as a subcommand
+lib.add_command(secrets_group)
+
+
 if __name__ == "__main__":
     lib()

mcli/lib/secrets/__init__.py

@@ -0,0 +1,10 @@
+"""
+Secrets management module for MCLI.
+
+Provides secure storage and retrieval of secrets with git-based synchronization.
+"""
+
+from .manager import SecretsManager
+from .store import SecretsStore
+
+__all__ = ["SecretsManager", "SecretsStore"]

mcli/lib/secrets/commands.py

@@ -0,0 +1,185 @@
+"""
+CLI commands for secrets management.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import click
+
+from mcli.lib.ui.styling import error, info, success, warning
+
+from .manager import SecretsManager
+from .repl import run_repl
+from .store import SecretsStore
+
+
+@click.group(name="secrets", help="Secure secrets management with encryption and git sync")
+def secrets_group():
+    """Secrets management commands."""
+    pass
+
+
+@secrets_group.command(name="repl", help="Launch interactive secrets shell")
+def secrets_repl():
+    """Launch the interactive secrets REPL."""
+    run_repl()
+
+
+@secrets_group.command(name="set", help="Set a secret value")
+@click.argument("key")
+@click.argument("value")
+@click.option("-n", "--namespace", default="default", help="Namespace for the secret")
+def secrets_set(key: str, value: str, namespace: str):
+    """Set a secret value."""
+    manager = SecretsManager()
+    try:
+        manager.set(key, value, namespace)
+        success(f"Secret '{key}' set in namespace '{namespace}'")
+    except Exception as e:
+        error(f"Failed to set secret: {e}")
+
+
+@secrets_group.command(name="get", help="Get a secret value")
+@click.argument("key")
+@click.option("-n", "--namespace", default="default", help="Namespace for the secret")
+@click.option("-s", "--show", is_flag=True, help="Show the full value (not masked)")
+def secrets_get(key: str, namespace: str, show: bool):
+    """Get a secret value."""
+    manager = SecretsManager()
+    value = manager.get(key, namespace)
+
+    if value is not None:
+        if show:
+            click.echo(value)
+        else:
+            # Mask the value
+            masked = (
+                value[:3] + "*" * (len(value) - 6) + value[-3:]
+                if len(value) > 6
+                else "*" * len(value)
+            )
+            info(f"{key} = {masked}")
+            info("Use --show to display the full value")
+    else:
+        warning(f"Secret '{key}' not found in namespace '{namespace}'")
+
+
+@secrets_group.command(name="list", help="List all secrets")
+@click.option("-n", "--namespace", help="Filter by namespace")
+def secrets_list(namespace: Optional[str]):
+    """List all secrets."""
+    manager = SecretsManager()
+    secrets = manager.list(namespace)
+
+    if secrets:
+        info("Secrets:")
+        for secret in secrets:
+            click.echo(f"  • {secret}")
+    else:
+        info("No secrets found")
+
+
+@secrets_group.command(name="delete", help="Delete a secret")
+@click.argument("key")
+@click.option("-n", "--namespace", default="default", help="Namespace for the secret")
+@click.confirmation_option(prompt="Are you sure you want to delete this secret?")
+def secrets_delete(key: str, namespace: str):
+    """Delete a secret."""
+    manager = SecretsManager()
+    if manager.delete(key, namespace):
+        success(f"Secret '{key}' deleted from namespace '{namespace}'")
+    else:
+        warning(f"Secret '{key}' not found in namespace '{namespace}'")
+
+
+@secrets_group.command(name="export", help="Export secrets as environment variables")
+@click.option("-n", "--namespace", help="Namespace to export")
+@click.option("-o", "--output", type=click.Path(), help="Output file (defaults to stdout)")
+def secrets_export(namespace: Optional[str], output: Optional[str]):
+    """Export secrets as environment variables."""
+    manager = SecretsManager()
+    env_vars = manager.export_env(namespace)
+
+    if env_vars:
+        if output:
+            with open(output, "w") as f:
+                for key, value in env_vars.items():
+                    f.write(f"export {key}={value}\n")
+            success(f"Exported {len(env_vars)} secrets to {output}")
+        else:
+            for key, value in env_vars.items():
+                click.echo(f"export {key}={value}")
+    else:
+        info("No secrets to export")
+
+
+@secrets_group.command(name="import", help="Import secrets from environment file")
+@click.argument("env_file", type=click.Path(exists=True))
+@click.option("-n", "--namespace", default="default", help="Namespace to import into")
+def secrets_import(env_file: str, namespace: str):
+    """Import secrets from environment file."""
+    manager = SecretsManager()
+    count = manager.import_env(Path(env_file), namespace)
+    success(f"Imported {count} secrets into namespace '{namespace}'")
+
+
+@secrets_group.group(name="store", help="Git-based secrets synchronization")
+def store_group():
+    """Store management commands."""
+    pass
+
+
+@store_group.command(name="init", help="Initialize secrets store")
+@click.option("-r", "--remote", help="Git remote URL")
+def store_init(remote: Optional[str]):
+    """Initialize the secrets store."""
+    store = SecretsStore()
+    store.init(remote)
+
+
+@store_group.command(name="push", help="Push secrets to store")
+@click.option("-m", "--message", help="Commit message")
+def store_push(message: Optional[str]):
+    """Push secrets to store."""
+    manager = SecretsManager()
+    store = SecretsStore()
+    store.push(manager.secrets_dir, message)
+
+
+@store_group.command(name="pull", help="Pull secrets from store")
+def store_pull():
+    """Pull secrets from store."""
+    manager = SecretsManager()
+    store = SecretsStore()
+    store.pull(manager.secrets_dir)
+
+
+@store_group.command(name="sync", help="Sync secrets with store")
+@click.option("-m", "--message", help="Commit message")
+def store_sync(message: Optional[str]):
+    """Sync secrets with store."""
+    manager = SecretsManager()
+    store = SecretsStore()
+    store.sync(manager.secrets_dir, message)
+
+
+@store_group.command(name="status", help="Show store status")
+def store_status():
+    """Show store status."""
+    store = SecretsStore()
+    status = store.status()
+
+    info("Secrets Store Status:")
+    click.echo(f"  Initialized: {status['initialized']}")
+    click.echo(f"  Path: {status['store_path']}")
+
+    if status["initialized"]:
+        click.echo(f"  Branch: {status['branch']}")
+        click.echo(f"  Commit: {status['commit']}")
+        click.echo(f"  Clean: {status['clean']}")
+
+        if status["has_remote"]:
+            click.echo(f"  Remote: {status['remote_url']}")
+        else:
+            click.echo("  Remote: Not configured")

mcli/lib/secrets/manager.py

@@ -0,0 +1,213 @@
+"""
+Secrets manager for handling secure storage and retrieval of secrets.
+"""
+
+import base64
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import click
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class SecretsManager:
+    """Manages secrets storage with encryption."""
+
+    def __init__(self, secrets_dir: Optional[Path] = None):
+        """Initialize the secrets manager.
+
+        Args:
+            secrets_dir: Directory to store secrets. Defaults to ~/.mcli/secrets/
+        """
+        self.secrets_dir = secrets_dir or Path.home() / ".mcli" / "secrets"
+        self.secrets_dir.mkdir(parents=True, exist_ok=True)
+        self._cipher_suite = self._get_cipher_suite()
+
+    def _get_cipher_suite(self) -> Fernet:
+        """Get or create encryption key."""
+        key_file = self.secrets_dir / ".key"
+
+        if key_file.exists():
+            with open(key_file, "rb") as f:
+                key = f.read()
+        else:
+            # Generate a new key from a password
+            password = click.prompt("Enter a password for secrets encryption", hide_input=True)
+            password_bytes = password.encode()
+
+            # Use PBKDF2 to derive a key from the password
+            kdf = PBKDF2HMAC(
+                algorithm=hashes.SHA256(),
+                length=32,
+                salt=b"mcli-secrets-salt",  # In production, use a random salt
+                iterations=100000,
+            )
+            key = base64.urlsafe_b64encode(kdf.derive(password_bytes))
+
+            # Save the key (in production, this should be stored more securely)
+            with open(key_file, "wb") as f:
+                f.write(key)
+
+            # Set restrictive permissions
+            os.chmod(key_file, 0o600)
+
+        return Fernet(key)
+
+    def set(self, key: str, value: str, namespace: Optional[str] = None) -> None:
+        """Set a secret value.
+
+        Args:
+            key: Secret key
+            value: Secret value
+            namespace: Optional namespace for grouping secrets
+        """
+        namespace = namespace or "default"
+        namespace_dir = self.secrets_dir / namespace
+        namespace_dir.mkdir(exist_ok=True)
+
+        # Encrypt the value
+        encrypted_value = self._cipher_suite.encrypt(value.encode())
+
+        # Store the encrypted value
+        secret_file = namespace_dir / f"{key}.secret"
+        with open(secret_file, "wb") as f:
+            f.write(encrypted_value)
+
+        # Set restrictive permissions
+        os.chmod(secret_file, 0o600)
+
+        logger.debug(f"Secret '{key}' stored in namespace '{namespace}'")
+
+    def get(self, key: str, namespace: Optional[str] = None) -> Optional[str]:
+        """Get a secret value.
+
+        Args:
+            key: Secret key
+            namespace: Optional namespace
+
+        Returns:
+            Decrypted secret value or None if not found
+        """
+        namespace = namespace or "default"
+        secret_file = self.secrets_dir / namespace / f"{key}.secret"
+
+        if not secret_file.exists():
+            return None
+
+        with open(secret_file, "rb") as f:
+            encrypted_value = f.read()
+
+        try:
+            decrypted_value = self._cipher_suite.decrypt(encrypted_value)
+            return decrypted_value.decode()
+        except Exception as e:
+            logger.error(f"Failed to decrypt secret '{key}': {e}")
+            return None
+
+    def list(self, namespace: Optional[str] = None) -> List[str]:
+        """List all secret keys.
+
+        Args:
+            namespace: Optional namespace filter
+
+        Returns:
+            List of secret keys
+        """
+        if namespace:
+            namespace_dirs = [self.secrets_dir / namespace]
+        else:
+            namespace_dirs = [
+                d for d in self.secrets_dir.iterdir() if d.is_dir() and not d.name.startswith(".")
+            ]
+
+        secrets = []
+        for namespace_dir in namespace_dirs:
+            if namespace_dir.exists():
+                for secret_file in namespace_dir.glob("*.secret"):
+                    key = secret_file.stem
+                    ns = namespace_dir.name
+                    secrets.append(f"{ns}/{key}" if not namespace else key)
+
+        return sorted(secrets)
+
+    def delete(self, key: str, namespace: Optional[str] = None) -> bool:
+        """Delete a secret.
+
+        Args:
+            key: Secret key
+            namespace: Optional namespace
+
+        Returns:
+            True if deleted, False if not found
+        """
+        namespace = namespace or "default"
+        secret_file = self.secrets_dir / namespace / f"{key}.secret"
+
+        if secret_file.exists():
+            secret_file.unlink()
+            logger.debug(f"Secret '{key}' deleted from namespace '{namespace}'")
+            return True
+
+        return False
+
+    def export_env(self, namespace: Optional[str] = None) -> Dict[str, str]:
+        """Export secrets as environment variables.
+
+        Args:
+            namespace: Optional namespace filter
+
+        Returns:
+            Dictionary of key-value pairs
+        """
+        env_vars = {}
+
+        for secret_key in self.list(namespace):
+            if "/" in secret_key:
+                ns, key = secret_key.split("/", 1)
+                value = self.get(key, ns)
+            else:
+                value = self.get(secret_key, namespace)
+
+            if value:
+                # Convert to uppercase for environment variable convention
+                if "/" in secret_key:
+                    env_key = key.upper().replace("-", "_")
+                else:
+                    env_key = secret_key.upper().replace("-", "_")
+                env_vars[env_key] = value
+
+        return env_vars
+
+    def import_env(self, env_file: Path, namespace: Optional[str] = None) -> int:
+        """Import secrets from an environment file.
+
+        Args:
+            env_file: Path to .env file
+            namespace: Optional namespace
+
+        Returns:
+            Number of secrets imported
+        """
+        namespace = namespace or "default"
+        count = 0
+
+        with open(env_file) as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    key, value = line.split("=", 1)
+                    key = key.strip()
+                    value = value.strip().strip('"').strip("'")
+
+                    self.set(key.lower().replace("_", "-"), value, namespace)
+                    count += 1
+
+        return count

mcli/lib/secrets/repl.py

@@ -0,0 +1,297 @@
+"""
+REPL (Read-Eval-Print Loop) for LSH secrets management.
+"""
+
+import os
+from pathlib import Path
+from typing import List
+
+import click
+from prompt_toolkit import prompt
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.history import FileHistory
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+from mcli.lib.ui.styling import console, error, info, success, warning
+
+from .manager import SecretsManager
+from .store import SecretsStore
+
+
+class SecretsREPL:
+    """Interactive REPL for secrets management."""
+
+    def __init__(self):
+        """Initialize the REPL."""
+        self.manager = SecretsManager()
+        self.store = SecretsStore()
+        self.running = False
+        self.namespace = "default"
+        self.history_file = Path.home() / ".mcli" / "secrets_repl_history"
+
+        # Commands
+        self.commands = {
+            "set": self.cmd_set,
+            "get": self.cmd_get,
+            "list": self.cmd_list,
+            "delete": self.cmd_delete,
+            "namespace": self.cmd_namespace,
+            "export": self.cmd_export,
+            "import": self.cmd_import,
+            "push": self.cmd_push,
+            "pull": self.cmd_pull,
+            "sync": self.cmd_sync,
+            "status": self.cmd_status,
+            "help": self.cmd_help,
+            "exit": self.cmd_exit,
+            "quit": self.cmd_exit,
+        }
+
+        # Command completer
+        self.completer = WordCompleter(list(self.commands.keys()) + ["ns"], ignore_case=True)
+
+    def run(self):
+        """Run the REPL."""
+        self.running = True
+
+        # Print welcome message
+        console.print("[bold cyan]MCLI Secrets Management Shell[/bold cyan]")
+        console.print("Type 'help' for available commands or 'exit' to quit.\n")
+
+        # Create history file directory if needed
+        self.history_file.parent.mkdir(parents=True, exist_ok=True)
+
+        while self.running:
+            try:
+                # Build prompt
+                prompt_text = f"[{self.namespace}]> "
+
+                # Get user input
+                user_input = prompt(
+                    prompt_text,
+                    completer=self.completer,
+                    history=FileHistory(str(self.history_file)),
+                    auto_suggest=AutoSuggestFromHistory(),
+                ).strip()
+
+                if not user_input:
+                    continue
+
+                # Parse command and arguments
+                parts = user_input.split()
+                command = parts[0].lower()
+                args = parts[1:] if len(parts) > 1 else []
+
+                # Handle command aliases
+                if command == "ns":
+                    command = "namespace"
+
+                # Execute command
+                if command in self.commands:
+                    self.commands[command](args)
+                else:
+                    error(f"Unknown command: {command}")
+                    console.print("Type 'help' for available commands.")
+
+            except KeyboardInterrupt:
+                console.print("\nUse 'exit' or 'quit' to leave the shell.")
+            except EOFError:
+                self.cmd_exit([])
+            except Exception as e:
+                error(f"Error: {e}")
+                logger.exception("REPL error")
+
+    def cmd_set(self, args: List[str]):
+        """Set a secret value."""
+        if len(args) < 2:
+            error("Usage: set <key> <value>")
+            return
+
+        key = args[0]
+        value = " ".join(args[1:])
+
+        try:
+            self.manager.set(key, value, self.namespace)
+            success(f"Secret '{key}' set in namespace '{self.namespace}'")
+        except Exception as e:
+            error(f"Failed to set secret: {e}")
+
+    def cmd_get(self, args: List[str]):
+        """Get a secret value."""
+        if len(args) != 1:
+            error("Usage: get <key>")
+            return
+
+        key = args[0]
+        value = self.manager.get(key, self.namespace)
+
+        if value is not None:
+            # Mask the value for security
+            masked_value = (
+                value[:3] + "*" * (len(value) - 6) + value[-3:]
+                if len(value) > 6
+                else "*" * len(value)
+            )
+            info(f"{key} = {masked_value}")
+
+            if click.confirm("Show full value?", default=False):
+                console.print(f"[yellow]{value}[/yellow]")
+        else:
+            warning(f"Secret '{key}' not found in namespace '{self.namespace}'")
+
+    def cmd_list(self, args: List[str]):
+        """List all secrets."""
+        secrets = self.manager.list(self.namespace if args != ["all"] else None)
+
+        if secrets:
+            console.print("[bold]Secrets:[/bold]")
+            for secret in secrets:
+                console.print(f"  • {secret}")
+        else:
+            info("No secrets found")
+
+    def cmd_delete(self, args: List[str]):
+        """Delete a secret."""
+        if len(args) != 1:
+            error("Usage: delete <key>")
+            return
+
+        key = args[0]
+
+        if click.confirm(f"Delete secret '{key}' from namespace '{self.namespace}'?"):
+            if self.manager.delete(key, self.namespace):
+                success(f"Secret '{key}' deleted")
+            else:
+                warning(f"Secret '{key}' not found")
+
+    def cmd_namespace(self, args: List[str]):
+        """Switch namespace."""
+        if len(args) == 0:
+            # List namespaces
+            namespaces = set()
+            for d in self.manager.secrets_dir.iterdir():
+                if d.is_dir() and not d.name.startswith("."):
+                    namespaces.add(d.name)
+
+            console.print(f"[bold]Current namespace:[/bold] {self.namespace}")
+            if namespaces:
+                console.print("[bold]Available namespaces:[/bold]")
+                for ns in sorted(namespaces):
+                    marker = "→" if ns == self.namespace else " "
+                    console.print(f"  {marker} {ns}")
+        elif len(args) == 1:
+            self.namespace = args[0]
+            success(f"Switched to namespace '{self.namespace}'")
+        else:
+            error("Usage: namespace [<name>]")
+
+    def cmd_export(self, args: List[str]):
+        """Export secrets as environment variables."""
+        env_vars = self.manager.export_env(self.namespace)
+
+        if env_vars:
+            if args and args[0] == "file":
+                # Export to file
+                filename = args[1] if len(args) > 1 else f"{self.namespace}.env"
+                with open(filename, "w") as f:
+                    for key, value in env_vars.items():
+                        f.write(f"{key}={value}\n")
+                success(f"Exported {len(env_vars)} secrets to {filename}")
+            else:
+                # Display export commands
+                console.print("[bold]Export commands:[/bold]")
+                for key, value in env_vars.items():
+                    masked_value = value[:3] + "***" + value[-3:] if len(value) > 6 else "***"
+                    console.print(f"export {key}={masked_value}")
+        else:
+            info("No secrets to export")
+
+    def cmd_import(self, args: List[str]):
+        """Import secrets from environment file."""
+        if len(args) != 1:
+            error("Usage: import <env-file>")
+            return
+
+        env_file = Path(args[0])
+        if not env_file.exists():
+            error(f"File not found: {env_file}")
+            return
+
+        count = self.manager.import_env(env_file, self.namespace)
+        success(f"Imported {count} secrets from {env_file}")
+
+    def cmd_push(self, args: List[str]):
+        """Push secrets to git store."""
+        message = " ".join(args) if args else None
+        self.store.push(self.manager.secrets_dir, message)
+
+    def cmd_pull(self, args: List[str]):
+        """Pull secrets from git store."""
+        self.store.pull(self.manager.secrets_dir)
+
+    def cmd_sync(self, args: List[str]):
+        """Sync secrets with git store."""
+        message = " ".join(args) if args else None
+        self.store.sync(self.manager.secrets_dir, message)
+
+    def cmd_status(self, args: List[str]):
+        """Show store status."""
+        status = self.store.status()
+
+        console.print("[bold]Secrets Store Status:[/bold]")
+        console.print(f"  Initialized: {status['initialized']}")
+        console.print(f"  Path: {status['store_path']}")
+
+        if status["initialized"]:
+            console.print(f"  Branch: {status['branch']}")
+            console.print(f"  Commit: {status['commit']}")
+            console.print(f"  Clean: {status['clean']}")
+
+            if status["has_remote"]:
+                console.print(f"  Remote: {status['remote_url']}")
+            else:
+                console.print("  Remote: [dim]Not configured[/dim]")
+
+    def cmd_help(self, args: List[str]):
+        """Show help information."""
+        console.print("[bold]Available Commands:[/bold]\n")
+
+        help_text = {
+            "set": "Set a secret value",
+            "get": "Get a secret value",
+            "list": "List all secrets (use 'list all' for all namespaces)",
+            "delete": "Delete a secret",
+            "namespace": "Switch namespace or list namespaces (alias: ns)",
+            "export": "Export secrets as environment variables",
+            "import": "Import secrets from .env file",
+            "push": "Push secrets to git store",
+            "pull": "Pull secrets from git store",
+            "sync": "Sync secrets with git store",
+            "status": "Show store status",
+            "help": "Show this help",
+            "exit": "Exit the shell (alias: quit)",
+        }
+
+        for cmd, desc in help_text.items():
+            console.print(f"  [cyan]{cmd:12}[/cyan] {desc}")
+
+        console.print("\n[bold]Examples:[/bold]")
+        console.print("  set api-key sk-1234567890")
+        console.print("  get api-key")
+        console.print("  namespace production")
+        console.print("  export file production.env")
+        console.print("  import .env.local")
+
+    def cmd_exit(self, args: List[str]):
+        """Exit the REPL."""
+        self.running = False
+        console.print("\nGoodbye!")
+
+
+def run_repl():
+    """Entry point for the REPL."""
+    repl = SecretsREPL()
+    repl.run()

mcli/lib/secrets/store.py

@@ -0,0 +1,246 @@
+"""
+Git-based secrets store for synchronization across machines.
+"""
+
+import os
+import shutil
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import click
+from git import GitCommandError, Repo
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+from mcli.lib.ui.styling import error, info, success, warning
+
+
+class SecretsStore:
+    """Manages git-based secrets synchronization."""
+
+    def __init__(self, store_path: Optional[Path] = None):
+        """Initialize the secrets store.
+
+        Args:
+            store_path: Path to git repository for secrets. Defaults to ~/repos/mcli-secrets
+        """
+        self.store_path = store_path or Path.home() / "repos" / "mcli-secrets"
+        self.config_file = Path.home() / ".mcli" / "secrets-store.conf"
+        self.load_config()
+
+    def load_config(self) -> None:
+        """Load store configuration."""
+        self.store_config = {}
+        if self.config_file.exists():
+            with open(self.config_file) as f:
+                for line in f:
+                    line = line.strip()
+                    if "=" in line:
+                        key, value = line.split("=", 1)
+                        self.store_config[key.strip()] = value.strip()
+
+        # Override store path if configured
+        if "store_path" in self.store_config:
+            self.store_path = Path(self.store_config["store_path"])
+
+    def save_config(self) -> None:
+        """Save store configuration."""
+        self.config_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_file, "w") as f:
+            for key, value in self.store_config.items():
+                f.write(f"{key}={value}\n")
+
+    def init(self, remote_url: Optional[str] = None) -> None:
+        """Initialize the secrets store repository.
+
+        Args:
+            remote_url: Optional git remote URL
+        """
+        if self.store_path.exists() and (self.store_path / ".git").exists():
+            error("Store already initialized")
+            return
+
+        self.store_path.mkdir(parents=True, exist_ok=True)
+
+        try:
+            repo = Repo.init(self.store_path)
+
+            # Create README
+            readme_path = self.store_path / "README.md"
+            readme_path.write_text(
+                "# MCLI Secrets Store\n\n"
+                "This repository stores encrypted secrets for MCLI.\n\n"
+                "**WARNING**: This repository contains encrypted sensitive data.\n"
+                "Ensure it is kept private and access is restricted.\n"
+            )
+
+            # Create .gitignore
+            gitignore_path = self.store_path / ".gitignore"
+            gitignore_path.write_text("*.key\n*.tmp\n.DS_Store\n")
+
+            repo.index.add([readme_path.name, gitignore_path.name])
+            repo.index.commit("Initial commit")
+
+            if remote_url:
+                repo.create_remote("origin", remote_url)
+                self.store_config["remote_url"] = remote_url
+                self.save_config()
+                info(f"Remote added: {remote_url}")
+
+            success(f"Secrets store initialized at {self.store_path}")
+
+        except GitCommandError as e:
+            error(f"Failed to initialize store: {e}")
+
+    def push(self, secrets_dir: Path, message: Optional[str] = None) -> None:
+        """Push secrets to the store.
+
+        Args:
+            secrets_dir: Directory containing encrypted secrets
+            message: Commit message
+        """
+        if not self._check_initialized():
+            return
+
+        try:
+            repo = Repo(self.store_path)
+
+            # Copy secrets to store
+            store_secrets_dir = self.store_path / "secrets"
+
+            # Remove existing secrets
+            if store_secrets_dir.exists():
+                shutil.rmtree(store_secrets_dir)
+
+            # Copy new secrets
+            shutil.copytree(secrets_dir, store_secrets_dir)
+
+            # Add to git
+            repo.index.add(["secrets"])
+
+            # Check if there are changes
+            if repo.is_dirty():
+                message = message or f"Update secrets from {os.uname().nodename}"
+                repo.index.commit(message)
+
+                # Push if remote exists
+                if "origin" in repo.remotes:
+                    info("Pushing to remote...")
+                    repo.remotes.origin.push()
+                    success("Secrets pushed to remote")
+                else:
+                    success("Secrets committed locally")
+            else:
+                info("No changes to push")
+
+        except GitCommandError as e:
+            error(f"Failed to push secrets: {e}")
+
+    def pull(self, secrets_dir: Path) -> None:
+        """Pull secrets from the store.
+
+        Args:
+            secrets_dir: Directory to store pulled secrets
+        """
+        if not self._check_initialized():
+            return
+
+        try:
+            repo = Repo(self.store_path)
+
+            # Pull from remote if exists
+            if "origin" in repo.remotes:
+                info("Pulling from remote...")
+                repo.remotes.origin.pull()
+
+            # Copy secrets from store
+            store_secrets_dir = self.store_path / "secrets"
+
+            if not store_secrets_dir.exists():
+                warning("No secrets found in store")
+                return
+
+            # Backup existing secrets
+            if secrets_dir.exists():
+                backup_dir = secrets_dir.parent / f"{secrets_dir.name}.backup"
+                if backup_dir.exists():
+                    shutil.rmtree(backup_dir)
+                shutil.move(str(secrets_dir), str(backup_dir))
+                info(f"Existing secrets backed up to {backup_dir}")
+
+            # Copy secrets from store
+            shutil.copytree(store_secrets_dir, secrets_dir)
+
+            success(f"Secrets pulled to {secrets_dir}")
+
+        except GitCommandError as e:
+            error(f"Failed to pull secrets: {e}")
+
+    def sync(self, secrets_dir: Path, message: Optional[str] = None) -> None:
+        """Synchronize secrets (pull then push).
+
+        Args:
+            secrets_dir: Directory containing secrets
+            message: Commit message
+        """
+        if not self._check_initialized():
+            return
+
+        info("Synchronizing secrets...")
+
+        # First pull
+        self.pull(secrets_dir)
+
+        # Then push
+        self.push(secrets_dir, message)
+
+    def status(self) -> Dict[str, Any]:
+        """Get status of the secrets store.
+
+        Returns:
+            Status information
+        """
+        status = {
+            "initialized": False,
+            "store_path": str(self.store_path),
+            "has_remote": False,
+            "remote_url": None,
+            "clean": True,
+            "branch": None,
+            "commit": None,
+        }
+
+        if not self._check_initialized(silent=True):
+            return status
+
+        try:
+            repo = Repo(self.store_path)
+            status["initialized"] = True
+            status["clean"] = not repo.is_dirty()
+            status["branch"] = repo.active_branch.name
+            status["commit"] = str(repo.head.commit)[:8]
+
+            if "origin" in repo.remotes:
+                status["has_remote"] = True
+                status["remote_url"] = repo.remotes.origin.url
+
+        except Exception:
+            pass
+
+        return status
+
+    def _check_initialized(self, silent: bool = False) -> bool:
+        """Check if store is initialized.
+
+        Args:
+            silent: Don't print error message
+
+        Returns:
+            True if initialized
+        """
+        if not self.store_path.exists() or not (self.store_path / ".git").exists():
+            if not silent:
+                error("Store not initialized. Run 'mcli secrets store init' first.")
+            return False
+        return True

mcli/self/self_cmd.py

@@ -1029,6 +1029,14 @@ try:
 except ImportError as e:
     logger.debug(f"Could not load redis command: {e}")
 
+try:
+    from mcli.self.zsh_cmd import zsh_group
+
+    self_app.add_command(zsh_group, name="zsh")
+    logger.debug("Added zsh command to self group")
+except ImportError as e:
+    logger.debug(f"Could not load zsh command: {e}")
+
 try:
     from mcli.self.visual_cmd import visual
 

mcli/self/zsh_cmd.py

@@ -0,0 +1,259 @@
+"""
+ZSH-specific commands and utilities for MCLI.
+"""
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import click
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+from mcli.lib.ui.styling import error, info, success, warning
+
+
+@click.group(name="zsh", help="ZSH shell integration and utilities")
+def zsh_group():
+    """ZSH-specific commands and utilities."""
+    pass
+
+
+@zsh_group.command(name="config", help="Configure ZSH for optimal MCLI experience")
+@click.option("--force", is_flag=True, help="Force reconfiguration even if already set up")
+def zsh_config(force: bool):
+    """Configure ZSH with MCLI-specific settings."""
+    zshrc = Path.home() / ".zshrc"
+
+    if not zshrc.exists():
+        if click.confirm("No .zshrc found. Create one?"):
+            zshrc.touch()
+        else:
+            warning("Configuration cancelled")
+            return
+
+    configs_added = []  # noqa: F841
+
+    # Read existing content
+    content = zshrc.read_text()
+
+    # MCLI configuration block
+    mcli_block_start = "# BEGIN MCLI ZSH CONFIG"
+    mcli_block_end = "# END MCLI ZSH CONFIG"
+
+    if mcli_block_start in content and not force:
+        info("MCLI ZSH configuration already exists. Use --force to reconfigure.")
+        return
+
+    # Remove old block if forcing
+    if mcli_block_start in content and force:
+        lines = content.split("\n")
+        new_lines = []
+        in_block = False
+
+        for line in lines:
+            if line.strip() == mcli_block_start:
+                in_block = True
+            elif line.strip() == mcli_block_end:
+                in_block = False
+                continue
+            elif not in_block:
+                new_lines.append(line)
+
+        content = "\n".join(new_lines)
+
+    # Build configuration
+    config_lines = [
+        "",
+        mcli_block_start,
+        "# MCLI aliases",
+        "alias m='mcli'",
+        "alias mc='mcli chat'",
+        "alias mw='mcli workflow'",
+        "alias ms='mcli self'",
+        "alias mls='mcli lib secrets'",
+        "alias mlsr='mcli lib secrets repl'",
+        "",
+        "# MCLI environment",
+        'export MCLI_HOME="$HOME/.mcli"',
+        'export PATH="$MCLI_HOME/bin:$PATH"',
+        "",
+        "# MCLI completion",
+        'fpath=("$HOME/.config/zsh/completions" $fpath)',
+        "autoload -U compinit && compinit",
+        "",
+        "# MCLI prompt integration (optional)",
+        '# PS1="%{$fg[cyan]%}[mcli]%{$reset_color%} $PS1"',
+        "",
+        mcli_block_end,
+        "",
+    ]
+
+    # Append configuration
+    with zshrc.open("a") as f:
+        f.write("\n".join(config_lines))
+
+    success("ZSH configuration added successfully!")
+
+    # Install completion if not already installed
+    completion_dir = Path.home() / ".config" / "zsh" / "completions"
+    completion_file = completion_dir / "_mcli"
+
+    if not completion_file.exists():
+        info("Installing ZSH completion...")
+        try:
+            subprocess.run(["mcli", "self", "completion", "install", "--shell=zsh"], check=True)
+            configs_added.append("completion")
+        except subprocess.CalledProcessError:
+            warning("Failed to install completion automatically")
+
+    info("\nConfigured:")
+    info("  • Aliases: m, mc, mw, ms, mls, mlsr")
+    info("  • Environment variables: MCLI_HOME, PATH")
+    info("  • Shell completion support")
+    info("\nReload your shell configuration:")
+    info("  source ~/.zshrc")
+
+
+@zsh_group.command(name="aliases", help="Show available ZSH aliases")
+def zsh_aliases():
+    """Display MCLI ZSH aliases."""
+    aliases = [
+        ("m", "mcli", "Main MCLI command"),
+        ("mc", "mcli chat", "Open chat interface"),
+        ("mw", "mcli workflow", "Workflow commands"),
+        ("ms", "mcli self", "Self management commands"),
+        ("mls", "mcli lib secrets", "Secrets management"),
+        ("mlsr", "mcli lib secrets repl", "Secrets REPL"),
+    ]
+
+    info("MCLI ZSH Aliases:")
+    for alias, command, desc in aliases:
+        click.echo(f"  {alias:<6} → {command:<25} # {desc}")
+
+
+@zsh_group.command(name="prompt", help="Configure ZSH prompt with MCLI integration")
+@click.option("--style", type=click.Choice(["simple", "powerline", "minimal"]), default="simple")
+def zsh_prompt(style: str):
+    """Add MCLI status to ZSH prompt."""
+    zshrc = Path.home() / ".zshrc"
+
+    if not zshrc.exists():
+        error("No .zshrc found")
+        return
+
+    prompt_configs = {
+        "simple": 'PS1="%{$fg[cyan]%}[mcli]%{$reset_color%} $PS1"',
+        "powerline": 'PS1="%{$fg[cyan]%} mcli %{$reset_color%}$PS1"',
+        "minimal": 'PS1="◆ $PS1"',
+    }
+
+    config = prompt_configs[style]
+
+    # Check if prompt section exists
+    content = zshrc.read_text()
+    prompt_marker = "# MCLI prompt integration"
+
+    if prompt_marker in content:
+        # Update existing prompt
+        lines = content.split("\n")
+        for i, line in enumerate(lines):
+            if line.strip() == prompt_marker:
+                if i + 1 < len(lines) and lines[i + 1].startswith("PS1="):
+                    lines[i + 1] = config
+                    content = "\n".join(lines)
+                    zshrc.write_text(content)
+                    success(f"Updated prompt to {style} style")
+                    break
+    else:
+        warning("MCLI ZSH configuration not found. Run 'mcli self zsh config' first.")
+
+
+@zsh_group.command(name="functions", help="Install useful ZSH functions")
+def zsh_functions():
+    """Install MCLI-specific ZSH functions."""
+    functions_dir = Path.home() / ".config" / "zsh" / "functions"
+    functions_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create mcli-quick function
+    quick_func = functions_dir / "mcli-quick"
+    quick_func.write_text(
+        """# Quick MCLI command runner
+mcli-quick() {
+    local cmd=$1
+    shift
+    mcli $cmd "$@" | head -20
+}"""
+    )
+
+    # Create mcli-fzf function for fuzzy finding
+    fzf_func = functions_dir / "mcli-fzf"
+    fzf_func.write_text(
+        """# Fuzzy find MCLI commands
+mcli-fzf() {
+    local cmd=$(mcli --help | grep -E '^  [a-z]' | awk '{print $1}' | fzf)
+    if [[ -n $cmd ]]; then
+        print -z "mcli $cmd "
+    fi
+}"""
+    )
+
+    # Add to zshrc
+    zshrc = Path.home() / ".zshrc"
+    if zshrc.exists():
+        content = zshrc.read_text()
+        fpath_line = f'fpath=("{functions_dir}" $fpath)'
+
+        if str(functions_dir) not in content:
+            with zshrc.open("a") as f:
+                f.write(f"\n# MCLI ZSH functions\n{fpath_line}\nautoload -U mcli-quick mcli-fzf\n")
+
+    success("ZSH functions installed:")
+    info("  • mcli-quick: Run MCLI commands with truncated output")
+    info("  • mcli-fzf: Fuzzy find MCLI commands (requires fzf)")
+
+
+@zsh_group.command(name="test", help="Test ZSH integration")
+def zsh_test():
+    """Test ZSH integration and configuration."""
+    checks = []
+
+    # Check if running in ZSH
+    shell = os.environ.get("SHELL", "")
+    if "zsh" in shell:
+        checks.append(("ZSH shell detected", True))
+    else:
+        checks.append(("ZSH shell detected", False))
+
+    # Check completion
+    completion_file = Path.home() / ".config" / "zsh" / "completions" / "_mcli"
+    checks.append(("Completion installed", completion_file.exists()))
+
+    # Check zshrc
+    zshrc = Path.home() / ".zshrc"
+    if zshrc.exists():
+        content = zshrc.read_text()
+        checks.append(("MCLI config in .zshrc", "BEGIN MCLI ZSH CONFIG" in content))
+        checks.append(("Completion in fpath", ".config/zsh/completions" in content))
+    else:
+        checks.append((".zshrc exists", False))
+
+    # Check aliases
+    try:
+        result = subprocess.run(["zsh", "-c", "alias | grep mcli"], capture_output=True, text=True)
+        checks.append(("Aliases configured", result.returncode == 0))
+    except:
+        checks.append(("Aliases configured", False))
+
+    # Display results
+    info("ZSH Integration Test Results:")
+    for check, passed in checks:
+        status = "✅" if passed else "❌"
+        click.echo(f"  {status} {check}")
+
+    if all(passed for _, passed in checks):
+        success("\nAll checks passed! ZSH integration is working correctly.")
+    else:
+        warning("\nSome checks failed. Run 'mcli self zsh config' to set up integration.")

{mcli_framework-7.8.5.dist-info → mcli_framework-7.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 7.8.5
+Version: 7.9.0
 Summary: Portable workflow framework - transform any script into a versioned, schedulable command. Store in ~/.mcli/commands/, version with lockfile, run as daemon or cron job.
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>
@@ -48,6 +48,7 @@ Requires-Dist: humanize<5.0.0,>=4.9.0
 Requires-Dist: psutil<6.0.0,>=5.9.0
 Requires-Dist: inquirerpy<0.4.0,>=0.3.4
 Requires-Dist: gitpython<4.0.0,>=3.1.40
+Requires-Dist: prompt-toolkit<4.0.0,>=3.0.0
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: websockets>=12.0

{mcli_framework-7.8.5.dist-info → mcli_framework-7.9.0.dist-info}/RECORD

@@ -5,7 +5,7 @@ mcli/config.toml,sha256=263yEVvP_W9F2zOLssUBgy7amKaRAFQuBrfxcMhKxaQ,1706
 mcli/app/__init__.py,sha256=D4RiKk2gOEXwanbe_jXyNSb5zdgNi47kahtskMnEwjY,489
 mcli/app/commands_cmd.py,sha256=gixyyrMV4wDLeTRRDlUx1NG46ceIswsIV3u-zPvtNjw,58655
 mcli/app/completion_helpers.py,sha256=e62C6w2N-XoD66GYYHgtvKKoD3kYMuIeBBGzVKbuL04,7497
-mcli/app/main.py,sha256=3ehRwx_-9M4yOa--CTsRq9EKyN1UukRGKXHSWNmul7I,18944
+mcli/app/main.py,sha256=aFQbKMTqClswmwwxpbS5zxVXOXcZMvF27LO19x1X7Cg,19208
 mcli/app/model_cmd.py,sha256=OkFxJwZFCO-8IH6j1FPq-32qqhitbDvrUGf3IooBL54,2562
 mcli/app/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcli/app/model/model.py,sha256=EUGu_td-hRlbf4OElkdk1-0p7WyuG7sZmb-Ux2-J9KY,39061
@@ -19,7 +19,7 @@ mcli/chat/system_controller.py,sha256=SuGvnIh2QObvM1DMicF3gGyeBkbz_xXS-hOOHjWx5j
 mcli/chat/system_integration.py,sha256=xQ11thOUswPg8r1HZkId6U3bTCOtMYngt0-mUYYXpt4,40196
 mcli/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcli/lib/custom_commands.py,sha256=PCC3uRLN6bcIKCh7GJ98vuNm5R2o9xRRCvCMQcIhj0o,14489
-mcli/lib/lib.py,sha256=mlp2INx-UKTOECcA7Kens9yNt2gJi7GbKWFmf4cxj0c,632
+mcli/lib/lib.py,sha256=-CFUfmcubYBxt3LDBY0uj9DF232pz8MPDu-Qg0Ocy8M,850
 mcli/lib/paths.py,sha256=k6sDwvD8QRzBkBOllvXkokameumpTjpJ7pQrP7z1en0,2455
 mcli/lib/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcli/lib/api/api.py,sha256=sPgAIYC8Z7AWV2TCBssNSKotbRggBqNLsbfzbjkhmUY,18558
@@ -57,6 +57,11 @@ mcli/lib/performance/uvloop_config.py,sha256=wyI5pQnec2RAhgm52HJ1AxYGFa3bjTa-Cjh
 mcli/lib/pickles/__init__.py,sha256=b7l9CLv8Aua5sROYAaA4raxpWTKSJxUumTLqmzlkb-I,33
 mcli/lib/pickles/pickles.py,sha256=O9dLJfyxViX-IyionbcjcsxHnq42XiLaAorsUrx9oZU,1448
 mcli/lib/search/cached_vectorizer.py,sha256=ShBSTqoyGNGTNAII34okxl4chzy7hqhO2R-jtTEF1_0,17996
+mcli/lib/secrets/__init__.py,sha256=amoAq00syRdQuII3BnvizGmhXbf6vZNN2qnrHtBROvA,241
+mcli/lib/secrets/commands.py,sha256=-PovQ4X1QV3LxqO3hRBIG8JkqA0SJlA_skcg-xCxg-M,6169
+mcli/lib/secrets/manager.py,sha256=kjHNQ7_TeQlF1ZyfhfKZ00Mu1wn06Vw6K8FQL0nyU1s,6698
+mcli/lib/secrets/repl.py,sha256=rmBFVi8lB4r3pRnicpX318IaTrtshPEaBqC-PZaMs0Y,10351
+mcli/lib/secrets/store.py,sha256=vl-K_OjqlNIvypf4BCwCbtNZPk91QngNYqhwWwKupDw,7838
 mcli/lib/services/data_pipeline.py,sha256=UwDpAByOL_PDMjD76aOTmCyStd_QBmCngZBMXVerR5Y,16475
 mcli/lib/services/lsh_client.py,sha256=sJSXlWBqnhNQy7TtYMmcAwBceUp45rYa_HgdyYF0WtI,16799
 mcli/lib/services/redis_service.py,sha256=5QwSB-FMIS1zdTNp8VSOrZfr_wrUK10Bfe2N1ZTy-90,12730
@@ -191,10 +196,11 @@ mcli/self/__init__.py,sha256=7hCrgaRb4oAgAf-kcyzqhJ5LFpW19jwF5bxowR4LwjY,41
 mcli/self/completion_cmd.py,sha256=FKNVc_4ikWTGbDHybiNZGdxrggvt6A6q1rnzuyFVzVM,7754
 mcli/self/logs_cmd.py,sha256=SCzZ4VZs6p42hksun_w4WN33xIZgmq7RjdWX8P2WcT4,15056
 mcli/self/redis_cmd.py,sha256=Cl0LQ3Mqt27gLeb542_xw6bJBbIE-CBmWyMmaUTSk8c,9426
-mcli/self/self_cmd.py,sha256=IhuBxXNvWuUl9gggAW-bLfphA_MJTQ6HDTKjRkGbSEI,37531
+mcli/self/self_cmd.py,sha256=531_8jfX6neSifSl_u3mCG_EcSkQJ9yXcFxklvMFea0,37760
 mcli/self/store_cmd.py,sha256=O6arjRr4qWQKh1QyVWtzyXq5R7yZEBL87FSI59Db7IY,13320
 mcli/self/test_cmd.py,sha256=WjzgoH1WFa79wc8A7O6UMuJfookLfgciUNcCMbKHAQQ,21
 mcli/self/visual_cmd.py,sha256=jXighahHxeM9HANQ2Brk6nKFgi2ZuQBOBH7PE5xhebk,9428
+mcli/self/zsh_cmd.py,sha256=63jKmfjhJp2zxJL2c37OdtdzDrnOreXXfyARN7TyfzU,8294
 mcli/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcli/workflow/lsh_integration.py,sha256=jop80DUjdOSxmqPb-gX_OBep5f1twViv-pXmkcFqBPY,13314
 mcli/workflow/workflow.py,sha256=P_W5LOB3lowvvlfEp3mGwS3eNq4tpbiUY-poFulAF9E,393
@@ -268,9 +274,9 @@ mcli/workflow/sync/test_cmd.py,sha256=neVgs9zEnKSxlvzDpFkuCGucqnzjrShm2OvJtHibsl
 mcli/workflow/videos/__init__.py,sha256=aV3DEoO7qdKJY4odWKoQbOKDQq4ludTeCLnZcupOFIM,25
 mcli/workflow/wakatime/__init__.py,sha256=wKG8cVIHVtMPhNRFGFtX43bRnocHqOMMkFMkmW-M6pU,2626
 mcli/workflow/wakatime/wakatime.py,sha256=sEjsUKa3-XyE8Ni6sAb_D3GAY5jDcA30KknW9YTbLTA,142
-mcli_framework-7.8.5.dist-info/licenses/LICENSE,sha256=sahwAMfrJv2-V66HNPTp7A9UmMjxtyejwTZZoWQvEcI,1075
-mcli_framework-7.8.5.dist-info/METADATA,sha256=0cVb6nBeHAaVhwARz0Up36ixqhdfliwfLR3cVAVtTC8,16374
-mcli_framework-7.8.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcli_framework-7.8.5.dist-info/entry_points.txt,sha256=dYrZbDIm-KUPsl1wfv600Kx_8sMy89phMkCihbDRgP8,261
-mcli_framework-7.8.5.dist-info/top_level.txt,sha256=_bnO8J2EUkliWivey_1le0UrnocFKmyVMQjbQ8iVXjc,5
-mcli_framework-7.8.5.dist-info/RECORD,,
+mcli_framework-7.9.0.dist-info/licenses/LICENSE,sha256=sahwAMfrJv2-V66HNPTp7A9UmMjxtyejwTZZoWQvEcI,1075
+mcli_framework-7.9.0.dist-info/METADATA,sha256=JNzXPY0C0wGjCEu8B8DR9r7EiFYlYQ0_DBNFAHrcgRk,16418
+mcli_framework-7.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcli_framework-7.9.0.dist-info/entry_points.txt,sha256=dYrZbDIm-KUPsl1wfv600Kx_8sMy89phMkCihbDRgP8,261
+mcli_framework-7.9.0.dist-info/top_level.txt,sha256=_bnO8J2EUkliWivey_1le0UrnocFKmyVMQjbQ8iVXjc,5
+mcli_framework-7.9.0.dist-info/RECORD,,