mcli-framework 7.1.0__py3-none-any.whl → 7.1.2__py3-none-any.whl

mcli/app/completion_cmd.py

@@ -6,8 +6,10 @@ for bash, zsh, and fish shells.
 """
 
 import os
-import click
 from pathlib import Path
+
+import click
+
 from mcli.lib.ui.styling import success
 
 
@@ -22,29 +24,29 @@ def completion():
 def bash_completion(ctx):
     """Generate bash completion script"""
     from click.shell_completion import BashComplete
-    
+
     # Get the root CLI app
     app = ctx.find_root().command
     complete = BashComplete(app, {}, "mcli", "complete")
     script = complete.source()
-    
+
     click.echo("# Bash completion script for MCLI")
     click.echo("# Add this to your ~/.bashrc or ~/.bash_profile:")
     click.echo()
     click.echo(script)
 
 
-@completion.command(name="zsh") 
+@completion.command(name="zsh")
 @click.pass_context
 def zsh_completion(ctx):
     """Generate zsh completion script"""
     from click.shell_completion import ZshComplete
-    
+
     # Get the root CLI app
     app = ctx.find_root().command
     complete = ZshComplete(app, {}, "mcli", "complete")
     script = complete.source()
-    
+
     click.echo("# Zsh completion script for MCLI")
     click.echo("# Add this to your ~/.zshrc:")
     click.echo()
@@ -56,12 +58,12 @@ def zsh_completion(ctx):
 def fish_completion(ctx):
     """Generate fish completion script"""
     from click.shell_completion import FishComplete
-    
+
     # Get the root CLI app
     app = ctx.find_root().command
     complete = FishComplete(app, {}, "mcli", "complete")
     script = complete.source()
-    
+
     click.echo("# Fish completion script for MCLI")
     click.echo("# Add this to ~/.config/fish/completions/mcli.fish:")
     click.echo()
@@ -69,45 +71,49 @@ def fish_completion(ctx):
 
 
 @completion.command(name="install")
-@click.option("--shell", type=click.Choice(['bash', 'zsh', 'fish']), 
-              help="Shell to install for (auto-detected if not specified)")
+@click.option(
+    "--shell",
+    type=click.Choice(["bash", "zsh", "fish"]),
+    help="Shell to install for (auto-detected if not specified)",
+)
 @click.pass_context
 def install_completion(ctx, shell):
     """Install shell completion for the current user"""
     import subprocess
-    
+
     # Auto-detect shell if not specified
     if not shell:
-        shell_path = os.environ.get('SHELL', '')
-        if 'bash' in shell_path:
-            shell = 'bash'
-        elif 'zsh' in shell_path:
-            shell = 'zsh'
-        elif 'fish' in shell_path:
-            shell = 'fish'
+        shell_path = os.environ.get("SHELL", "")
+        if "bash" in shell_path:
+            shell = "bash"
+        elif "zsh" in shell_path:
+            shell = "zsh"
+        elif "fish" in shell_path:
+            shell = "fish"
         else:
             click.echo("❌ Could not auto-detect shell. Please specify --shell")
             return
-    
+
     # Get the root CLI app
     app = ctx.find_root().command
-    
+
     try:
-        if shell == 'bash':
+        if shell == "bash":
             from click.shell_completion import BashComplete
+
             complete = BashComplete(app, {}, "mcli", "complete")
             script = complete.source()
-            
+
             # Install to bash completion directory
             bash_completion_dir = Path.home() / ".bash_completion.d"
             bash_completion_dir.mkdir(exist_ok=True)
             completion_file = bash_completion_dir / "mcli"
             completion_file.write_text(script)
-            
+
             # Add sourcing to .bashrc if needed
             bashrc = Path.home() / ".bashrc"
             source_line = f"[ -f {completion_file} ] && source {completion_file}"
-            
+
             if bashrc.exists():
                 content = bashrc.read_text()
                 if source_line not in content:
@@ -120,50 +126,54 @@ def install_completion(ctx, shell):
                 click.echo(f"✅ Completion installed to {completion_file}")
                 click.echo("💡 Add this to your ~/.bashrc:")
                 click.echo(source_line)
-                
-        elif shell == 'zsh':
-            from click.shell_completion import ZshComplete  
+
+        elif shell == "zsh":
+            from click.shell_completion import ZshComplete
+
             complete = ZshComplete(app, {}, "mcli", "complete")
             script = complete.source()
-            
+
             # Install to zsh completion directory
             zsh_completion_dir = Path.home() / ".config" / "zsh" / "completions"
             zsh_completion_dir.mkdir(parents=True, exist_ok=True)
             completion_file = zsh_completion_dir / "_mcli"
             completion_file.write_text(script)
-            
+
             # Add to fpath in .zshrc if needed
             zshrc = Path.home() / ".zshrc"
             fpath_line = f'fpath=("{zsh_completion_dir}" $fpath)'
-            
+
             if zshrc.exists():
                 content = zshrc.read_text()
                 if str(zsh_completion_dir) not in content:
                     with zshrc.open("a") as f:
-                        f.write(f"\n# MCLI completion\n{fpath_line}\nautoload -U compinit && compinit\n")
-                    click.echo("✅ Added completion to ~/.zshrc") 
+                        f.write(
+                            f"\n# MCLI completion\n{fpath_line}\nautoload -U compinit && compinit\n"
+                        )
+                    click.echo("✅ Added completion to ~/.zshrc")
                 else:
                     click.echo("ℹ️  Completion already configured in ~/.zshrc")
             else:
                 click.echo(f"✅ Completion installed to {completion_file}")
                 click.echo("💡 Add this to your ~/.zshrc:")
                 click.echo(f"{fpath_line}\nautoload -U compinit && compinit")
-                
-        elif shell == 'fish':
+
+        elif shell == "fish":
             from click.shell_completion import FishComplete
+
             complete = FishComplete(app, {}, "mcli", "complete")
             script = complete.source()
-            
+
             # Install to fish completion directory
             fish_completion_dir = Path.home() / ".config" / "fish" / "completions"
             fish_completion_dir.mkdir(parents=True, exist_ok=True)
             completion_file = fish_completion_dir / "mcli.fish"
             completion_file.write_text(script)
             click.echo(f"✅ Completion installed to {completion_file}")
-        
+
         click.echo(f"🎉 Shell completion for {shell} installed successfully!")
         click.echo("💡 Restart your shell or source your profile to enable completions")
-        
+
     except Exception as e:
         click.echo(f"❌ Failed to install completion: {e}")
 
@@ -171,39 +181,39 @@ def install_completion(ctx, shell):
 @completion.command(name="status")
 def completion_status():
     """Check current shell completion status"""
-    current_shell = os.environ.get('SHELL', 'unknown')
-    shell_name = Path(current_shell).name if current_shell != 'unknown' else 'unknown'
-    
+    current_shell = os.environ.get("SHELL", "unknown")
+    shell_name = Path(current_shell).name if current_shell != "unknown" else "unknown"
+
     click.echo(f"🐚 Current shell: {shell_name} ({current_shell})")
     click.echo()
-    
+
     # Check for existing completions
     completions_found = []
-    
+
     # Check bash
     bash_completion = Path.home() / ".bash_completion.d" / "mcli"
     if bash_completion.exists():
         completions_found.append(f"✅ Bash completion: {bash_completion}")
     else:
         completions_found.append("❌ Bash completion: Not installed")
-    
+
     # Check zsh
-    zsh_completion = Path.home() / ".config" / "zsh" / "completions" / "_mcli"  
+    zsh_completion = Path.home() / ".config" / "zsh" / "completions" / "_mcli"
     if zsh_completion.exists():
         completions_found.append(f"✅ Zsh completion: {zsh_completion}")
     else:
         completions_found.append("❌ Zsh completion: Not installed")
-    
+
     # Check fish
     fish_completion = Path.home() / ".config" / "fish" / "completions" / "mcli.fish"
     if fish_completion.exists():
         completions_found.append(f"✅ Fish completion: {fish_completion}")
     else:
         completions_found.append("❌ Fish completion: Not installed")
-    
+
     for status in completions_found:
         click.echo(status)
-    
+
     click.echo()
     click.echo("💡 To install completion for your shell:")
     click.echo("   mcli completion install")
@@ -212,5 +222,5 @@ def completion_status():
     click.echo(f"   mcli completion {shell_name}")
 
 
-# Export the CLI group for registration  
-cli = completion
+# Export the CLI group for registration
+cli = completion

mcli/app/completion_helpers.py

@@ -2,7 +2,8 @@
 Completion helpers for MCLI that provide tab completion without loading heavy modules
 """
 
-from typing import List, Dict, Any
+from typing import Any, Dict, List
+
 import click
 from click.shell_completion import CompletionItem
 
@@ -11,12 +12,12 @@ LAZY_COMMAND_COMPLETIONS = {
     "workflow": {
         "subcommands": [
             "api-daemon",
-            "daemon", 
+            "daemon",
             "file",
             "politician-trading",
             "scheduler",
             "sync",
-            "videos"
+            "videos",
         ],
         "politician-trading": {
             "subcommands": [
@@ -24,7 +25,7 @@ LAZY_COMMAND_COMPLETIONS = {
                 "cron-job",
                 "data-sources",
                 "disclosures",
-                "health", 
+                "health",
                 "jobs",
                 "monitor",
                 "politicians",
@@ -34,105 +35,50 @@ LAZY_COMMAND_COMPLETIONS = {
                 "stats",
                 "status",
                 "test-workflow",
-                "verify"
+                "verify",
             ],
-            "cron-job": {
-                "options": ["--create", "--test"]
-            },
+            "cron-job": {"options": ["--create", "--test"]},
             "setup": {
                 "options": ["--create-tables", "--verify", "--generate-schema", "--output-dir"]
             },
-            "run": {
-                "options": ["--full", "--us-only", "--eu-only"]
-            },
-            "connectivity": {
-                "options": ["--json", "--continuous", "--interval", "--duration"]
-            },
-            "health": {
-                "options": ["--json"]
-            },
-            "monitor": {
-                "options": ["--interval", "--count"]  
-            },
-            "status": {
-                "options": ["--json"]
-            },
-            "stats": {
-                "options": ["--json"]
-            },
-            "test-workflow": {
-                "options": ["--verbose", "--validate-writes"]
-            },
-            "schema": {
-                "options": ["--show-location", "--generate", "--output-dir"]
-            },
-            "data-sources": {
-                "options": ["--json"]
-            },
-            "jobs": {
-                "options": ["--json", "--limit"]
-            },
+            "run": {"options": ["--full", "--us-only", "--eu-only"]},
+            "connectivity": {"options": ["--json", "--continuous", "--interval", "--duration"]},
+            "health": {"options": ["--json"]},
+            "monitor": {"options": ["--interval", "--count"]},
+            "status": {"options": ["--json"]},
+            "stats": {"options": ["--json"]},
+            "test-workflow": {"options": ["--verbose", "--validate-writes"]},
+            "schema": {"options": ["--show-location", "--generate", "--output-dir"]},
+            "data-sources": {"options": ["--json"]},
+            "jobs": {"options": ["--json", "--limit"]},
             "politicians": {
                 "options": ["--json", "--limit", "--role", "--party", "--state", "--search"]
             },
             "disclosures": {
-                "options": ["--json", "--limit", "--politician", "--asset", "--transaction-type", "--amount-min", "--amount-max", "--days", "--details"]
+                "options": [
+                    "--json",
+                    "--limit",
+                    "--politician",
+                    "--asset",
+                    "--transaction-type",
+                    "--amount-min",
+                    "--amount-max",
+                    "--days",
+                    "--details",
+                ]
             },
-            "verify": {
-                "options": ["--json"]
-            }
+            "verify": {"options": ["--json"]},
         },
         "scheduler": {
-            "subcommands": [
-                "add",
-                "cancel", 
-                "list",
-                "monitor",
-                "remove",
-                "start",
-                "status",
-                "stop"
-            ]
-        },
-        "daemon": {
-            "subcommands": [
-                "start",
-                "stop", 
-                "status",
-                "logs"
-            ]
+            "subcommands": ["add", "cancel", "list", "monitor", "remove", "start", "status", "stop"]
         },
-        "api-daemon": {
-            "subcommands": [
-                "start",
-                "stop",
-                "status", 
-                "logs"
-            ]
-        },
-        "videos": {
-            "subcommands": [
-                "remove-overlay",
-                "extract-frames",
-                "create-video"
-            ]
-        },
-        "sync": {
-            "subcommands": [
-                "status",
-                "sync"
-            ]
-        },
-        "file": {
-            "subcommands": [
-                "search",
-                "organize"
-            ]
-        }
-    },
-    "chat": {
-        "options": ["--model", "--system", "--temperature", "--max-tokens", "--stream"]
+        "daemon": {"subcommands": ["start", "stop", "status", "logs"]},
+        "api-daemon": {"subcommands": ["start", "stop", "status", "logs"]},
+        "videos": {"subcommands": ["remove-overlay", "extract-frames", "create-video"]},
+        "sync": {"subcommands": ["status", "sync"]},
+        "file": {"subcommands": ["search", "organize"]},
     },
+    "chat": {"options": ["--model", "--system", "--temperature", "--max-tokens", "--stream"]},
     "model": {
         "subcommands": [
             "download",
@@ -142,79 +88,51 @@ LAZY_COMMAND_COMPLETIONS = {
             "pull",
             "delete",
             "recommend",
-            "status"
-        ]
-    },
-    "cron-test": {
-        "options": ["--quick", "--cleanup", "--verbose"]
-    },
-    "visual": {
-        "subcommands": [
-            "demo",
-            "spinner-test"
-        ]
-    },
-    "redis": {
-        "subcommands": [
-            "start",
-            "stop",
             "status",
-            "flush"
-        ]
-    },
-    "logs": {
-        "subcommands": [
-            "tail",
-            "view",
-            "clear"
         ]
     },
+    "cron-test": {"options": ["--quick", "--cleanup", "--verbose"]},
+    "visual": {"subcommands": ["demo", "spinner-test"]},
+    "redis": {"subcommands": ["start", "stop", "status", "flush"]},
+    "logs": {"subcommands": ["tail", "view", "clear"]},
     "completion": {
-        "subcommands": [
-            "bash",
-            "zsh", 
-            "fish",
-            "install",
-            "status"
-        ],
-        "install": {
-            "options": ["--shell"]
-        }
-    }
+        "subcommands": ["bash", "zsh", "fish", "install", "status"],
+        "install": {"options": ["--shell"]},
+    },
 }
 
 
 def get_completion_items(cmd_path: List[str], incomplete: str = "") -> List[CompletionItem]:
     """Get completion items for a given command path without loading modules"""
     items = []
-    
+
     # Navigate to the completion data for this path
     current_data = LAZY_COMMAND_COMPLETIONS
-    
+
     for part in cmd_path:
         if part in current_data:
             current_data = current_data[part]
         else:
             return items  # No completion data available
-    
+
     # Add subcommands
     if "subcommands" in current_data:
         for subcommand in current_data["subcommands"]:
             if subcommand.startswith(incomplete):
                 items.append(CompletionItem(subcommand))
-    
-    # Add options  
+
+    # Add options
     if "options" in current_data:
         for option in current_data["options"]:
             if option.startswith(incomplete):
                 items.append(CompletionItem(option))
-    
+
     return items
 
 
 class CompletionAwareLazyGroup(click.Group):
     """A Click group that provides completion without loading modules"""
-    
+
     def __init__(self, name, import_path, *args, **kwargs):
         self.import_path = import_path
         self._loaded_group = None
@@ -225,6 +143,7 @@ class CompletionAwareLazyGroup(click.Group):
         if self._loaded_group is None:
             try:
                 import importlib
+
                 module_path, attr_name = self.import_path.rsplit(".", 1)
                 module = importlib.import_module(module_path)
                 self._loaded_group = getattr(module, attr_name)
@@ -232,6 +151,7 @@ class CompletionAwareLazyGroup(click.Group):
                 # Return a dummy group that shows an error
                 def error_callback():
                     click.echo(f"Error: Command group {self.name} is not available")
+
                 self._loaded_group = click.Group(self.name, callback=error_callback)
         return self._loaded_group
 
@@ -252,13 +172,13 @@ class CompletionAwareLazyGroup(click.Group):
             data = LAZY_COMMAND_COMPLETIONS[self.name]
             if "subcommands" in data:
                 return sorted(data["subcommands"])
-        
+
         # Try to get from static completion data for other commands
         if self.name in LAZY_COMMAND_COMPLETIONS:
             data = LAZY_COMMAND_COMPLETIONS[self.name]
             if "subcommands" in data:
                 return sorted(data["subcommands"])
-        
+
         # Fallback to loading the actual group
         group = self._load_group()
         return group.list_commands(ctx)
@@ -274,10 +194,10 @@ class CompletionAwareLazyGroup(click.Group):
                     if subcommand.startswith(incomplete):
                         items.append(CompletionItem(subcommand))
                 return items
-        
+
         # Fallback to loading the actual group
         group = self._load_group()
-        if hasattr(group, 'shell_complete'):
+        if hasattr(group, "shell_complete"):
             return group.shell_complete(ctx, incomplete)
         return []
 
@@ -287,6 +207,8 @@ class CompletionAwareLazyGroup(click.Group):
         return group.get_params(ctx)
 
 
-def create_completion_aware_lazy_group(name: str, import_path: str, help_text: str = None) -> CompletionAwareLazyGroup:
+def create_completion_aware_lazy_group(
+    name: str, import_path: str, help_text: str = None
+) -> CompletionAwareLazyGroup:
     """Create a completion-aware lazy group"""
-    return CompletionAwareLazyGroup(name, import_path, help=help_text)
+    return CompletionAwareLazyGroup(name, import_path, help=help_text)

mcli/app/logs_cmd.py

@@ -120,8 +120,18 @@ def list_logs(date: Optional[str]):
 @click.argument("log_type", type=click.Choice(["main", "trace", "system"]))
 @click.option("--lines", "-n", type=int, default=20, help="Number of lines to show (default: 20)")
 @click.option("--date", "-d", help="Date for log file (YYYYMMDD format, default: today)")
-def tail_logs(log_type: str, lines: int, date: Optional[str]):
-    """Show the last N lines of a specific log file"""
+@click.option(
+    "--follow",
+    "-f",
+    is_flag=True,
+    help="Follow log output in real-time (like tail -f)",
+)
+def tail_logs(log_type: str, lines: int, date: Optional[str], follow: bool):
+    """Show the last N lines of a specific log file
+
+    By default, shows the last N lines and exits. Use --follow/-f to
+    continuously monitor the log file for new entries (similar to tail -f).
+    """
     logs_dir = get_logs_dir()
 
     # Note: get_logs_dir() creates the directory automatically
@@ -144,17 +154,40 @@ def tail_logs(log_type: str, lines: int, date: Optional[str]):
         return
 
     try:
-        # Read last N lines
-        with open(log_file, "r") as f:
-            all_lines = f.readlines()
-            tail_lines = all_lines[-lines:] if len(all_lines) > lines else all_lines
-
-        # Display with formatting
-        console.print(f"\n📋 **Last {len(tail_lines)} lines from {log_file.name}**\n", style="cyan")
-
-        for line in tail_lines:
-            formatted_line = _format_log_line(line.rstrip())
-            console.print(formatted_line)
+        if follow:
+            # Follow mode: continuously stream new lines
+            console.print(f"\n📡 **Following {log_file.name}** (last {lines} lines)", style="cyan")
+            console.print("Press Ctrl+C to stop\n")
+
+            # Use tail -f for real-time following
+            cmd = ["tail", f"-n{lines}", "-f", str(log_file)]
+            process = subprocess.Popen(
+                cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+            )
+
+            try:
+                for line in iter(process.stdout.readline, ""):
+                    if line:
+                        formatted_line = _format_log_line(line.rstrip())
+                        console.print(formatted_line)
+            except KeyboardInterrupt:
+                process.terminate()
+                console.print("\n👋 Log following stopped", style="cyan")
+        else:
+            # Standard mode: just show last N lines
+            # Read last N lines
+            with open(log_file, "r") as f:
+                all_lines = f.readlines()
+                tail_lines = all_lines[-lines:] if len(all_lines) > lines else all_lines
+
+            # Display with formatting
+            console.print(
+                f"\n📋 **Last {len(tail_lines)} lines from {log_file.name}**\n", style="cyan"
+            )
+
+            for line in tail_lines:
+                formatted_line = _format_log_line(line.rstrip())
+                console.print(formatted_line)
 
     except Exception as e:
         console.print(f"❌ Error reading log file: {e}", style="red")