mcli-framework 7.12.2__py3-none-any.whl → 7.12.4__py3-none-any.whl

mcli/workflow/daemon/daemon.py

@@ -7,10 +7,10 @@ import sys
 import tempfile
 import time
 import uuid
-from dataclasses import asdict, dataclass
+from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
 import click
 import psutil
@@ -44,12 +44,11 @@ class CommandDatabase:
 
     def __init__(self, db_path: Optional[str] = None):
         logger.debug("CommandDatabase stub initialized - commands now managed via JSON files")
-        pass
 
 
 @dataclass
 class Command:
-    """Represents a stored command"""
+    """Represents a stored command."""
 
     id: str
     name: str
@@ -155,7 +154,7 @@ def start_command_file_watcher(db, watch_dir: str = None):
         self._update_embeddings()
 
     def init_database(self):
-        """Initialize SQLite database"""
+        """Initialize SQLite database."""
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
 
@@ -213,7 +212,7 @@ def start_command_file_watcher(db, watch_dir: str = None):
         conn.close()
 
     def _update_embeddings(self):
-        """Update TF-IDF embeddings for similarity search"""
+        """Update TF-IDF embeddings for similarity search."""
         commands = self.get_all_commands()
         if not commands:
             return
@@ -229,7 +228,7 @@ def start_command_file_watcher(db, watch_dir: str = None):
             self.vectorizer.fit(texts)
 
     def add_command(self, command: Command) -> str:
-        """Add a new command to the database"""
+        """Add a new command to the database."""
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
 
@@ -269,7 +268,7 @@ def start_command_file_watcher(db, watch_dir: str = None):
             conn.close()
 
     def get_command(self, command_id: str) -> Optional[Command]:
-        """Get a command by ID"""
+        """Get a command by ID."""
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
 
@@ -292,7 +291,7 @@ def start_command_file_watcher(db, watch_dir: str = None):
             conn.close()
 
     def get_all_commands(self, include_inactive: bool = False) -> List[Command]:
-        """Get all commands, optionally including inactive ones"""
+        """Get all commands, optionally including inactive ones."""
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
         try:
@@ -319,7 +318,7 @@ def start_command_file_watcher(db, watch_dir: str = None):
             conn.close()
 
     def search_commands(self, query: str, limit: int = 10) -> List[Command]:
-        """Search commands by name, description, or tags"""
+        """Search commands by name, description, or tags."""
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
 
@@ -345,7 +344,7 @@ def start_command_file_watcher(db, watch_dir: str = None):
             conn.close()
 
     def find_similar_commands(self, query: str, limit: int = 5) -> List[tuple]:
-        """Find similar commands using cosine similarity"""
+        """Find similar commands using cosine similarity."""
         commands = self.get_all_commands()
         if not commands:
             return []
@@ -383,7 +382,7 @@ def start_command_file_watcher(db, watch_dir: str = None):
             return []
 
     def update_command(self, command: Command) -> bool:
-        """Update an existing command"""
+        """Update an existing command."""
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
 
@@ -420,7 +419,7 @@ def start_command_file_watcher(db, watch_dir: str = None):
             conn.close()
 
     def delete_command(self, command_id: str) -> bool:
-        """Delete a command (soft delete)"""
+        """Delete a command (soft delete)."""
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
 
@@ -451,7 +450,7 @@ def start_command_file_watcher(db, watch_dir: str = None):
         error: str = None,
         execution_time_ms: int = None,
     ):
-        """Record command execution"""
+        """Record command execution."""
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
 
@@ -495,7 +494,7 @@ def start_command_file_watcher(db, watch_dir: str = None):
             conn.close()
 
     def _row_to_command(self, row) -> Command:
-        """Convert database row to Command object"""
+        """Convert database row to Command object."""
         return Command(
             id=row[0],
             name=row[1],
@@ -513,7 +512,7 @@ def start_command_file_watcher(db, watch_dir: str = None):
 
 
 class CommandExecutor:
-    """Handles safe execution of commands in different languages"""
+    """Handles safe execution of commands in different languages."""
 
     def __init__(self, temp_dir: Optional[str] = None):
         self.temp_dir = Path(temp_dir) if temp_dir else Path(tempfile.gettempdir()) / "mcli_daemon"
@@ -528,7 +527,7 @@ class CommandExecutor:
         }
 
     def execute_command(self, command: Command, args: List[str] = None) -> Dict[str, Any]:
-        """Execute a command safely"""
+        """Execute a command safely."""
         start_time = time.time()
 
         try:
@@ -561,7 +560,7 @@ class CommandExecutor:
             }
 
     def _execute_python(self, command: Command, args: List[str]) -> Dict[str, str]:
-        """Execute Python code safely"""
+        """Execute Python code safely."""
         # Create temporary file
         script_file = self.temp_dir / f"{command.id}_{int(time.time())}.py"
 
@@ -587,7 +586,7 @@ class CommandExecutor:
                 script_file.unlink()
 
     def _execute_node(self, command: Command, args: List[str]) -> Dict[str, str]:
-        """Execute Node.js code safely"""
+        """Execute Node.js code safely."""
         script_file = self.temp_dir / f"{command.id}_{int(time.time())}.js"
 
         try:
@@ -609,7 +608,7 @@ class CommandExecutor:
                 script_file.unlink()
 
     def _execute_lua(self, command: Command, args: List[str]) -> Dict[str, str]:
-        """Execute Lua code safely"""
+        """Execute Lua code safely."""
         script_file = self.temp_dir / f"{command.id}_{int(time.time())}.lua"
 
         try:
@@ -631,7 +630,7 @@ class CommandExecutor:
                 script_file.unlink()
 
     def _execute_shell(self, command: Command, args: List[str]) -> Dict[str, str]:
-        """Execute shell commands safely"""
+        """Execute shell commands safely."""
         script_file = self.temp_dir / f"{command.id}_{int(time.time())}.sh"
 
         try:
@@ -658,7 +657,7 @@ class CommandExecutor:
 
 
 class DaemonService:
-    """Background daemon service for command management"""
+    """Background daemon service for command management."""
 
     def __init__(self, config_path: Optional[str] = None):
         # Load configuration from TOML
@@ -696,7 +695,7 @@ class DaemonService:
         self.pid_file.parent.mkdir(parents=True, exist_ok=True)
 
     def start(self):
-        """Start the daemon service"""
+        """Start the daemon service."""
         if self.running:
             logger.info("Daemon is already running")
             return
@@ -734,7 +733,7 @@ class DaemonService:
             self.stop()
 
     def stop(self):
-        """Stop the daemon service"""
+        """Stop the daemon service."""
         if not self.running:
             return
 
@@ -747,13 +746,13 @@ class DaemonService:
         logger.info("Daemon stopped")
 
     def _signal_handler(self, signum, frame):
-        """Handle shutdown signals"""
+        """Handle shutdown signals."""
         logger.info(f"Received signal {signum}, shutting down...")
         self.stop()
         sys.exit(0)
 
     def _main_loop(self):
-        """Main daemon loop"""
+        """Main daemon loop."""
         logger.info("Daemon main loop started")
 
         while self.running:
@@ -768,7 +767,7 @@ class DaemonService:
                 time.sleep(5)
 
     def status(self) -> Dict[str, Any]:
-        """Get daemon status"""
+        """Get daemon status."""
         is_running = False
         pid = None
 
@@ -791,21 +790,20 @@ class DaemonService:
 # CLI Commands
 @click.group(name="daemon")
 def daemon():
-    """Daemon service for command management"""
-    pass
+    """Daemon service for command management."""
 
 
 @daemon.command()
 @click.option("--config", help="Path to configuration file")
 def start(config: Optional[str]):
-    """Start the daemon service"""
+    """Start the daemon service."""
     service = DaemonService(config)
     service.start()
 
 
 @daemon.command()
 def stop():
-    """Stop the daemon service"""
+    """Stop the daemon service."""
     pid_file = Path.home() / ".local" / "mcli" / "daemon" / "daemon.pid"
 
     if not pid_file.exists():
@@ -833,7 +831,7 @@ def stop():
 
 @daemon.command()
 def status():
-    """Show daemon status"""
+    """Show daemon status."""
     service = DaemonService()
     status_info = service.status()
     if status_info["running"]:
@@ -849,8 +847,7 @@ def status():
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
 @click.option("--all", "show_all", is_flag=True, help="Show all commands, including inactive")
 def list_commands(as_json, show_all):
-    """List all available commands (optionally including inactive)"""
-    import sys
+    """List all available commands (optionally including inactive)."""
 
     service = DaemonService()
     commands = service.db.get_all_commands(include_inactive=show_all)
@@ -887,8 +884,7 @@ def list_commands(as_json, show_all):
 @click.argument("args", nargs=-1)
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
 def execute_command(command_name, args, as_json):
-    """Execute a command by name with optional arguments"""
-    import sys
+    """Execute a command by name with optional arguments."""
 
     service = DaemonService()
     # Find command by name

mcli/workflow/daemon/enhanced_daemon.py

@@ -4,24 +4,15 @@ Enhanced async daemon with Rust extensions and performance optimizations
 
 import asyncio
 import json
-import os
 import signal
 import uuid
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-import aiosqlite
-import redis.asyncio as redis
-
 from mcli.lib.logger.logger import get_logger
-from mcli.lib.performance.rust_bridge import (
-    get_command_matcher,
-    get_file_watcher,
-    get_process_manager,
-    get_tfidf_vectorizer,
-)
-from mcli.lib.search.cached_vectorizer import CachedTfIdfVectorizer, SmartVectorizerManager
+from mcli.lib.performance.rust_bridge import get_command_matcher, get_file_watcher
+from mcli.lib.search.cached_vectorizer import SmartVectorizerManager
 from mcli.workflow.daemon.async_command_database import (
     AsyncCommandDatabase,
     Command,
@@ -33,7 +24,7 @@ logger = get_logger(__name__)
 
 
 class EnhancedDaemon:
-    """High-performance async daemon with Rust extensions"""
+    """High-performance async daemon with Rust extensions."""
 
     def __init__(
         self, db_path: Optional[str] = None, redis_url: Optional[str] = None, use_rust: bool = True
@@ -64,7 +55,7 @@ class EnhancedDaemon:
         }
 
     async def initialize(self):
-        """Initialize all daemon components"""
+        """Initialize all daemon components."""
         logger.info("Initializing Enhanced Daemon...")
 
         try:
@@ -96,7 +87,7 @@ class EnhancedDaemon:
             raise
 
     async def _initialize_rust_components(self):
-        """Initialize Rust-based components"""
+        """Initialize Rust-based components."""
         try:
             # File watcher
             self.file_watcher = get_file_watcher(use_rust=self.use_rust)
@@ -138,7 +129,7 @@ class EnhancedDaemon:
             logger.warning(f"Failed to initialize some Rust components: {e}")
 
     def _setup_signal_handlers(self):
-        """Setup signal handlers for graceful shutdown"""
+        """Setup signal handlers for graceful shutdown."""
 
         def signal_handler():
             logger.info("Received shutdown signal")
@@ -152,7 +143,7 @@ class EnhancedDaemon:
                 signal.signal(sig, lambda s, f: asyncio.create_task(self.shutdown()))
 
     async def start(self):
-        """Start the daemon"""
+        """Start the daemon."""
         if self.running:
             logger.warning("Daemon is already running")
             return
@@ -182,7 +173,7 @@ class EnhancedDaemon:
             logger.info("Enhanced Daemon stopped")
 
     async def shutdown(self):
-        """Graceful shutdown"""
+        """Graceful shutdown."""
         if not self.running:
             return
 
@@ -208,7 +199,7 @@ class EnhancedDaemon:
             await self.vectorizer_manager.close_all()
 
     async def _file_watcher_loop(self):
-        """Background loop for processing file system events"""
+        """Background loop for processing file system events."""
         if not self.file_watcher:
             return
 
@@ -227,7 +218,7 @@ class EnhancedDaemon:
                 await asyncio.sleep(5)  # Back off on error
 
     async def _handle_file_event(self, event):
-        """Handle a file system event"""
+        """Handle a file system event."""
         try:
             event_type = event.get("event_type") or event.get("type", "unknown")
             path = event.get("path", "")
@@ -244,7 +235,7 @@ class EnhancedDaemon:
             logger.error(f"Error handling file event {event}: {e}")
 
     async def _reload_command_file(self, file_path: str):
-        """Reload a command from a JSON file"""
+        """Reload a command from a JSON file."""
         try:
             with open(file_path, "r") as f:
                 data = json.load(f)
@@ -286,7 +277,7 @@ class EnhancedDaemon:
             logger.error(f"Failed to reload command file {file_path}: {e}")
 
     async def _remove_command_file(self, file_path: str):
-        """Remove a command when its file is deleted"""
+        """Remove a command when its file is deleted."""
         try:
             # Extract command ID from filename
             command_id = Path(file_path).stem
@@ -300,7 +291,7 @@ class EnhancedDaemon:
             logger.error(f"Failed to remove command file {file_path}: {e}")
 
     async def _maintenance_loop(self):
-        """Background maintenance tasks"""
+        """Background maintenance tasks."""
         while self.running:
             try:
                 # Clean up finished processes
@@ -320,7 +311,7 @@ class EnhancedDaemon:
                 await asyncio.sleep(60)
 
     async def _metrics_loop(self):
-        """Background metrics collection"""
+        """Background metrics collection."""
         while self.running:
             try:
                 # Log performance metrics every 10 minutes
@@ -339,7 +330,7 @@ class EnhancedDaemon:
                 await asyncio.sleep(60)
 
     async def _update_search_indexes(self):
-        """Update search indexes for better performance"""
+        """Update search indexes for better performance."""
         try:
             # Get all commands
             commands = await self.command_db.get_all_commands()
@@ -366,7 +357,7 @@ class EnhancedDaemon:
     # Public API methods
 
     async def add_command(self, command_data: Dict[str, Any]) -> str:
-        """Add a new command"""
+        """Add a new command."""
         command = Command(
             id=command_data.get("id") or str(uuid.uuid4()),
             name=command_data["name"],
@@ -396,7 +387,7 @@ class EnhancedDaemon:
         return command_id
 
     async def search_commands(self, query: str, limit: int = 10) -> List[Dict[str, Any]]:
-        """Search for commands"""
+        """Search for commands."""
         self.metrics["search_queries"] += 1
 
         # Try Rust command matcher first
@@ -465,7 +456,7 @@ class EnhancedDaemon:
     async def execute_command(
         self, command_id: str, context: Optional[Dict[str, Any]] = None
     ) -> str:
-        """Execute a command"""
+        """Execute a command."""
         self.metrics["commands_executed"] += 1
 
         # Get command
@@ -498,7 +489,7 @@ class EnhancedDaemon:
         return process_id
 
     def _get_command_executor(self, language: str) -> str:
-        """Get the appropriate executor for a language"""
+        """Get the appropriate executor for a language."""
         executors = {
             "python": "python",
             "node": "node",
@@ -509,7 +500,7 @@ class EnhancedDaemon:
         return executors.get(language, "bash")
 
     def _prepare_command_args(self, command: Command) -> List[str]:
-        """Prepare command arguments based on language"""
+        """Prepare command arguments based on language."""
         if command.language == "python":
             return ["-c", command.code]
         elif command.language == "node":
@@ -522,7 +513,7 @@ class EnhancedDaemon:
             return [command.code]
 
     async def get_status(self) -> Dict[str, Any]:
-        """Get daemon status"""
+        """Get daemon status."""
         return {
             "running": self.running,
             "uptime": (
@@ -546,7 +537,7 @@ _daemon_instance: Optional[EnhancedDaemon] = None
 
 
 async def get_daemon() -> EnhancedDaemon:
-    """Get the global daemon instance"""
+    """Get the global daemon instance."""
     global _daemon_instance
 
     if _daemon_instance is None:
@@ -557,13 +548,13 @@ async def get_daemon() -> EnhancedDaemon:
 
 
 async def start_daemon():
-    """Start the global daemon"""
+    """Start the global daemon."""
     daemon = await get_daemon()
     await daemon.start()
 
 
 async def stop_daemon():
-    """Stop the global daemon"""
+    """Stop the global daemon."""
     global _daemon_instance
 
     if _daemon_instance:

mcli/workflow/daemon/process_cli.py

@@ -14,15 +14,14 @@ API_BASE_URL = "http://localhost:8000"
 
 @click.group(name="process")
 def process_cli():
-    """Docker-like process management commands"""
-    pass
+    """Docker-like process management commands."""
 
 
 @process_cli.command("ps")
 @click.option("--all", "-a", is_flag=True, help="Show all processes including exited ones")
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
 def list_processes(all: bool, as_json: bool):
-    """List processes (like 'docker ps')"""
+    """List processes (like 'docker ps')."""
     try:
         params = {"all": "true"} if all else {}
         response = requests.get(f"{API_BASE_URL}/processes", params=params)
@@ -66,7 +65,7 @@ def list_processes(all: bool, as_json: bool):
 def run_process(
     command: str, args: tuple, name: Optional[str], detach: bool, working_dir: Optional[str]
 ):
-    """Create and start a process (like 'docker run')"""
+    """Create and start a process (like 'docker run')."""
     try:
         data = {
             "name": name or f"proc-{command}",
@@ -98,7 +97,7 @@ def run_process(
 @click.argument("process_id")
 @click.option("--lines", "-n", type=int, help="Number of lines to show from end of logs")
 def show_logs(process_id: str, lines: Optional[int]):
-    """Show logs for a process (like 'docker logs')"""
+    """Show logs for a process (like 'docker logs')."""
     try:
         params = {}
         if lines:
@@ -128,7 +127,7 @@ def show_logs(process_id: str, lines: Optional[int]):
 @click.argument("process_id")
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
 def inspect_process(process_id: str, as_json: bool):
-    """Show detailed information about a process (like 'docker inspect')"""
+    """Show detailed information about a process (like 'docker inspect')."""
     try:
         response = requests.get(f"{API_BASE_URL}/processes/{process_id}")
 
@@ -150,7 +149,7 @@ def inspect_process(process_id: str, as_json: bool):
 
             if info.get("stats"):
                 stats = info["stats"]
-                click.echo(f"\nResource Usage:")
+                click.echo("\nResource Usage:")
                 click.echo(f"  CPU: {stats.get('cpu_percent', 0):.1f}%")
                 click.echo(f"  Memory: {stats.get('memory_mb', 0):.1f} MB")
                 click.echo(f"  Uptime: {stats.get('uptime_seconds', 0)} seconds")
@@ -168,7 +167,7 @@ def inspect_process(process_id: str, as_json: bool):
 @click.argument("process_id")
 @click.option("--timeout", "-t", type=int, default=10, help="Timeout in seconds")
 def stop_process(process_id: str, timeout: int):
-    """Stop a process (like 'docker stop')"""
+    """Stop a process (like 'docker stop')."""
     try:
         data = {"timeout": timeout}
         response = requests.post(f"{API_BASE_URL}/processes/{process_id}/stop", json=data)
@@ -187,7 +186,7 @@ def stop_process(process_id: str, timeout: int):
 @process_cli.command("start")
 @click.argument("process_id")
 def start_process(process_id: str):
-    """Start a stopped process (like 'docker start')"""
+    """Start a stopped process (like 'docker start')."""
     try:
         response = requests.post(f"{API_BASE_URL}/processes/{process_id}/start")
 
@@ -205,7 +204,7 @@ def start_process(process_id: str):
 @process_cli.command("kill")
 @click.argument("process_id")
 def kill_process(process_id: str):
-    """Kill a process (like 'docker kill')"""
+    """Kill a process (like 'docker kill')."""
     try:
         response = requests.post(f"{API_BASE_URL}/processes/{process_id}/kill")
 
@@ -222,9 +221,9 @@ def kill_process(process_id: str):
 
 @process_cli.command("rm")
 @click.argument("process_id")
-@click.option("--force", "-f", is_flag=True, help="Force remove running process")
+@click.option("--force", "-", is_flag=True, help="Force remove running process")
 def remove_process(process_id: str, force: bool):
-    """Remove a process (like 'docker rm')"""
+    """Remove a process (like 'docker rm')."""
     try:
         params = {"force": "true"} if force else {}
         response = requests.delete(f"{API_BASE_URL}/processes/{process_id}", params=params)