mcli-framework 7.0.0__py3-none-any.whl

mcli/workflow/daemon/commands.py

@@ -0,0 +1,1196 @@
+import hashlib
+import json
+import logging
+import os
+import pickle
+import shutil
+import signal
+import sqlite3
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import uuid
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import click
+import psutil
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Import existing utilities
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class Command:
+    """Represents a stored command"""
+
+    id: str
+    name: str
+    description: str
+    code: str
+    language: str  # 'python', 'node', 'lua', 'shell'
+    group: Optional[str] = None
+    tags: List[str] = None
+    created_at: datetime = None
+    updated_at: datetime = None
+    execution_count: int = 0
+    last_executed: Optional[datetime] = None
+    is_active: bool = True
+
+    def __post_init__(self):
+        if self.tags is None:
+            self.tags = []
+        if self.created_at is None:
+            self.created_at = datetime.now()
+        if self.updated_at is None:
+            self.updated_at = datetime.now()
+
+
+class CommandDatabase:
+    """Manages command storage and retrieval"""
+
+    def __init__(self, db_path: Optional[str] = None):
+        if db_path is None:
+            db_path = Path.home() / ".local" / "mcli" / "daemon" / "commands.db"
+
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self.init_database()
+
+        # Initialize vectorizer for similarity search
+        self.vectorizer = TfidfVectorizer(
+            max_features=1000, stop_words="english", ngram_range=(1, 2)
+        )
+        self._update_embeddings()
+
+    def init_database(self):
+        """Initialize SQLite database"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        # Commands table
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS commands (
+                id TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                description TEXT,
+                code TEXT NOT NULL,
+                language TEXT NOT NULL,
+                group_name TEXT,
+                tags TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                execution_count INTEGER DEFAULT 0,
+                last_executed TIMESTAMP,
+                is_active BOOLEAN DEFAULT 1
+            )
+        """
+        )
+
+        # Groups table for hierarchical organization
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS groups (
+                id TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                description TEXT,
+                parent_group_id TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (parent_group_id) REFERENCES groups (id)
+            )
+        """
+        )
+
+        # Execution history
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS executions (
+                id TEXT PRIMARY KEY,
+                command_id TEXT NOT NULL,
+                executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                status TEXT NOT NULL,
+                output TEXT,
+                error TEXT,
+                execution_time_ms INTEGER,
+                FOREIGN KEY (command_id) REFERENCES commands (id)
+            )
+        """
+        )
+
+        conn.commit()
+        conn.close()
+
+    def _update_embeddings(self):
+        """Update TF-IDF embeddings for similarity search"""
+        commands = self.get_all_commands()
+        if not commands:
+            return
+
+        # Combine name, description, and tags for embedding
+        texts = []
+        for cmd in commands:
+            text_parts = [cmd.name, cmd.description or ""]
+            text_parts.extend(cmd.tags or [])
+            texts.append(" ".join(text_parts))
+
+        if texts:
+            self.vectorizer.fit(texts)
+
+    def add_command(self, command: Command) -> str:
+        """Add a new command to the database"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        try:
+            cursor.execute(
+                """
+                INSERT INTO commands 
+                (id, name, description, code, language, group_name, tags, 
+                 created_at, updated_at, execution_count, last_executed, is_active)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+                (
+                    command.id,
+                    command.name,
+                    command.description,
+                    command.code,
+                    command.language,
+                    command.group,
+                    json.dumps(command.tags),
+                    command.created_at.isoformat(),
+                    command.updated_at.isoformat(),
+                    command.execution_count,
+                    command.last_executed.isoformat() if command.last_executed else None,
+                    command.is_active,
+                ),
+            )
+
+            conn.commit()
+            self._update_embeddings()
+            return command.id
+
+        except Exception as e:
+            logger.error(f"Error adding command: {e}")
+            conn.rollback()
+            raise
+        finally:
+            conn.close()
+
+    def get_command(self, command_id: str) -> Optional[Command]:
+        """Get a command by ID"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        try:
+            cursor.execute(
+                """
+                SELECT id, name, description, code, language, group_name, tags,
+                       created_at, updated_at, execution_count, last_executed, is_active
+                FROM commands WHERE id = ?
+            """,
+                (command_id,),
+            )
+
+            row = cursor.fetchone()
+            if row:
+                return self._row_to_command(row)
+            return None
+
+        finally:
+            conn.close()
+
+    def get_all_commands(self, include_inactive: bool = False) -> List[Command]:
+        """Get all commands with optional inactive inclusion"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        try:
+            query = """
+                SELECT id, name, description, code, language, group_name, tags,
+                       created_at, updated_at, execution_count, last_executed, is_active
+                FROM commands
+            """
+            if not include_inactive:
+                query += " WHERE is_active = 1"
+            query += " ORDER BY name"
+
+            cursor.execute(query)
+
+            return [self._row_to_command(row) for row in cursor.fetchall()]
+
+        finally:
+            conn.close()
+
+    def search_commands(self, query: str, limit: int = 10) -> List[Command]:
+        """Search commands by name, description, or tags"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        try:
+            # Simple text search
+            search_term = f"%{query}%"
+            cursor.execute(
+                """
+                SELECT id, name, description, code, language, group_name, tags,
+                       created_at, updated_at, execution_count, last_executed, is_active
+                FROM commands 
+                WHERE is_active = 1 
+                AND (name LIKE ? OR description LIKE ? OR tags LIKE ? OR language LIKE ?)
+                ORDER BY name
+                LIMIT ?
+            """,
+                (search_term, search_term, search_term, search_term, limit),
+            )
+
+            return [self._row_to_command(row) for row in cursor.fetchall()]
+
+        finally:
+            conn.close()
+
+    def find_similar_commands(self, query: str, limit: int = 5) -> List[tuple]:
+        """Find similar commands using cosine similarity"""
+        cmd_list = self.get_all_commands()
+        if not cmd_list:
+            return []
+
+        # Prepare query text
+        query_text = query.lower()
+
+        # Get command texts for comparison
+        command_texts = []
+        for cmd in cmd_list:
+            text_parts = [cmd.name, cmd.description or ""]
+            text_parts.extend(cmd.tags or [])
+            command_texts.append(" ".join(text_parts).lower())
+
+        if not command_texts:
+            return []
+
+        # Calculate similarities
+        try:
+            # Re-fit vectorizer with current commands if needed
+            if len(command_texts) > 0:
+                # Create a temporary vectorizer for this search
+                temp_vectorizer = TfidfVectorizer(
+                    max_features=1000, stop_words="english", ngram_range=(1, 2)
+                )
+
+                # Fit on current command texts
+                all_texts = command_texts + [query_text]
+                temp_vectorizer.fit(all_texts)
+
+                # Transform query and commands
+                query_vector = temp_vectorizer.transform([query_text])
+                command_vectors = temp_vectorizer.transform(command_texts)
+
+                # Calculate cosine similarities
+                similarities = cosine_similarity(query_vector, command_vectors).flatten()
+
+                # Sort by similarity - avoid using 'commands' variable name
+                cmd_similarities = []
+                for i, similarity_score in enumerate(similarities):
+                    cmd_similarities.append((cmd_list[i], similarity_score))
+
+                cmd_similarities.sort(key=lambda x: x[1], reverse=True)
+
+                return cmd_similarities[:limit]
+            else:
+                return []
+
+        except Exception as e:
+            logger.error(f"Error calculating similarities: {e}")
+            import traceback
+
+            traceback.print_exc()
+            return []
+
+    def update_command(self, command: Command) -> bool:
+        """Update an existing command"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        try:
+            cursor.execute(
+                """
+                UPDATE commands 
+                SET name = ?, description = ?, code = ?, language = ?, 
+                    group_name = ?, tags = ?, updated_at = ?, is_active = ?
+                WHERE id = ?
+            """,
+                (
+                    command.name,
+                    command.description,
+                    command.code,
+                    command.language,
+                    command.group,
+                    json.dumps(command.tags),
+                    datetime.now().isoformat(),
+                    command.is_active,
+                    command.id,
+                ),
+            )
+
+            conn.commit()
+            self._update_embeddings()
+            return cursor.rowcount > 0
+
+        except Exception as e:
+            logger.error(f"Error updating command: {e}")
+            conn.rollback()
+            return False
+        finally:
+            conn.close()
+
+    def delete_command(self, command_id: str) -> bool:
+        """Delete a command (soft delete)"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        try:
+            cursor.execute(
+                """
+                UPDATE commands SET is_active = 0 WHERE id = ?
+            """,
+                (command_id,),
+            )
+
+            conn.commit()
+            self._update_embeddings()
+            return cursor.rowcount > 0
+
+        except Exception as e:
+            logger.error(f"Error deleting command: {e}")
+            conn.rollback()
+            return False
+        finally:
+            conn.close()
+
+    def record_execution(
+        self,
+        command_id: str,
+        status: str,
+        output: str = None,
+        error: str = None,
+        execution_time_ms: int = None,
+    ):
+        """Record command execution"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        try:
+            # Record execution
+            execution_id = str(uuid.uuid4())
+            cursor.execute(
+                """
+                INSERT INTO executions 
+                (id, command_id, executed_at, status, output, error, execution_time_ms)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+                (
+                    execution_id,
+                    command_id,
+                    datetime.now().isoformat(),
+                    status,
+                    output,
+                    error,
+                    execution_time_ms,
+                ),
+            )
+
+            # Update command stats
+            cursor.execute(
+                """
+                UPDATE commands 
+                SET execution_count = execution_count + 1, 
+                    last_executed = ?
+                WHERE id = ?
+            """,
+                (datetime.now().isoformat(), command_id),
+            )
+
+            conn.commit()
+
+        except Exception as e:
+            logger.error(f"Error recording execution: {e}")
+            conn.rollback()
+        finally:
+            conn.close()
+
+    def _row_to_command(self, row) -> Command:
+        """Convert database row to Command object"""
+        return Command(
+            id=row[0],
+            name=row[1],
+            description=row[2],
+            code=row[3],
+            language=row[4],
+            group=row[5],
+            tags=json.loads(row[6]) if row[6] else [],
+            created_at=datetime.fromisoformat(row[7]),
+            updated_at=datetime.fromisoformat(row[8]),
+            execution_count=row[9],
+            last_executed=datetime.fromisoformat(row[10]) if row[10] else None,
+            is_active=bool(row[11]),
+        )
+
+
+class CommandExecutor:
+    """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"
+        self.temp_dir.mkdir(parents=True, exist_ok=True)
+
+        # Language-specific execution environments
+        self.language_handlers = {
+            "python": self._execute_python,
+            "node": self._execute_node,
+            "lua": self._execute_lua,
+            "shell": self._execute_shell,
+        }
+
+    def execute_command(self, command: Command, args: List[str] = None) -> Dict[str, Any]:
+        """Execute a command safely"""
+        start_time = time.time()
+
+        try:
+            # Get the appropriate handler
+            handler = self.language_handlers.get(command.language)
+            if not handler:
+                raise ValueError(f"Unsupported language: {command.language}")
+
+            # Execute the command
+            result = handler(command, args or [])
+
+            execution_time = int((time.time() - start_time) * 1000)
+
+            # Check if execution was successful
+            returncode = result.get("returncode", 0)
+            success = returncode == 0
+            status = "completed" if success else "failed"
+
+            return {
+                "success": success,
+                "output": result.get("output", ""),
+                "error": result.get("error", ""),
+                "execution_time_ms": execution_time,
+                "status": status,
+            }
+
+        except Exception as e:
+            execution_time = int((time.time() - start_time) * 1000)
+            return {
+                "success": False,
+                "output": "",
+                "error": str(e),
+                "execution_time_ms": execution_time,
+                "status": "failed",
+            }
+
+    def _execute_python(self, command: Command, args: List[str]) -> Dict[str, str]:
+        """Execute Python code safely with resource limits and sandboxing"""
+        # Create secure temporary file
+        script_file = self.temp_dir / f"{command.id}_{int(time.time())}.py"
+        script_file.touch(mode=0o700)  # Restrict permissions
+
+        # Add resource limits
+        resource_limits = """
+import resource
+resource.setrlimit(resource.RLIMIT_CPU, (1, 1))  # 1 second CPU time
+resource.setrlimit(resource.RLIMIT_AS, (256*1024*1024, 256*1024*1024))  # 256MB memory
+"""
+
+        try:
+            # Write code to file
+            with open(script_file, "w") as f:
+                f.write(command.code)
+
+            # Execute with subprocess
+            result = subprocess.run(
+                [sys.executable, str(script_file)] + args,
+                capture_output=True,
+                text=True,
+                timeout=30,  # 30 second timeout
+                cwd=self.temp_dir,
+            )
+
+            return {
+                "output": result.stdout,
+                "error": result.stderr,
+                "returncode": result.returncode,
+            }
+
+        finally:
+            # Clean up
+            if script_file.exists():
+                script_file.unlink()
+
+    def _execute_node(self, command: Command, args: List[str]) -> Dict[str, str]:
+        """Execute Node.js code safely"""
+        script_file = self.temp_dir / f"{command.id}_{int(time.time())}.js"
+
+        try:
+            with open(script_file, "w") as f:
+                f.write(command.code)
+
+            result = subprocess.run(
+                ["node", str(script_file)] + args,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                cwd=self.temp_dir,
+            )
+
+            return {
+                "output": result.stdout,
+                "error": result.stderr,
+                "returncode": result.returncode,
+            }
+
+        finally:
+            if script_file.exists():
+                script_file.unlink()
+
+    def _execute_lua(self, command: Command, args: List[str]) -> Dict[str, str]:
+        """Execute Lua code safely"""
+        script_file = self.temp_dir / f"{command.id}_{int(time.time())}.lua"
+
+        try:
+            with open(script_file, "w") as f:
+                f.write(command.code)
+
+            result = subprocess.run(
+                ["lua", str(script_file)] + args,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                cwd=self.temp_dir,
+            )
+
+            return {
+                "output": result.stdout,
+                "error": result.stderr,
+                "returncode": result.returncode,
+            }
+
+        finally:
+            if script_file.exists():
+                script_file.unlink()
+
+    def _execute_shell(self, command: Command, args: List[str]) -> Dict[str, str]:
+        """Execute shell commands safely"""
+        script_file = self.temp_dir / f"{command.id}_{int(time.time())}.sh"
+
+        try:
+            with open(script_file, "w") as f:
+                f.write("#!/bin/bash\n")
+                f.write(command.code)
+
+            # Make executable
+            script_file.chmod(0o755)
+
+            result = subprocess.run(
+                [str(script_file)] + args,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                cwd=self.temp_dir,
+            )
+
+            return {
+                "output": result.stdout,
+                "error": result.stderr,
+                "returncode": result.returncode,
+            }
+
+        finally:
+            if script_file.exists():
+                script_file.unlink()
+
+
+class DaemonService:
+    """Background daemon service for command management"""
+
+    def __init__(self, config_path: Optional[str] = None):
+        self.db = CommandDatabase()
+        self.executor = CommandExecutor()
+        self.running = False
+        self.pid_file = Path.home() / ".local" / "mcli" / "daemon" / "daemon.pid"
+        self.socket_file = Path.home() / ".local" / "mcli" / "daemon" / "daemon.sock"
+
+        # Ensure daemon directory exists
+        self.pid_file.parent.mkdir(parents=True, exist_ok=True)
+
+    def start(self):
+        """Start the daemon service"""
+        if self.running:
+            logger.info("Daemon is already running")
+            return
+
+        # Check if already running
+        if self.pid_file.exists():
+            try:
+                with open(self.pid_file, "r") as f:
+                    pid = int(f.read().strip())
+                if psutil.pid_exists(pid):
+                    logger.info(f"Daemon already running with PID {pid}")
+                    return
+            except Exception:
+                pass
+
+        # Start daemon
+        self.running = True
+
+        # Write PID file
+        with open(self.pid_file, "w") as f:
+            f.write(str(os.getpid()))
+
+        logger.info(f"Daemon started with PID {os.getpid()}")
+
+        # Set up signal handlers
+        signal.signal(signal.SIGTERM, self._signal_handler)
+        signal.signal(signal.SIGINT, self._signal_handler)
+
+        # Start main loop
+        try:
+            self._main_loop()
+        except KeyboardInterrupt:
+            logger.info("Daemon interrupted")
+        finally:
+            self.stop()
+
+    def stop(self):
+        """Stop the daemon service"""
+        if not self.running:
+            return
+
+        self.running = False
+
+        # Remove PID file
+        if self.pid_file.exists():
+            self.pid_file.unlink()
+
+        logger.info("Daemon stopped")
+
+    def _signal_handler(self, signum, frame):
+        """Handle shutdown signals"""
+        logger.info(f"Received signal {signum}, shutting down...")
+        self.stop()
+        sys.exit(0)
+
+    def _main_loop(self):
+        """Main daemon loop"""
+        logger.info("Daemon main loop started")
+
+        while self.running:
+            try:
+                # Check for commands to execute
+                # This is a simple implementation - in a real system you'd use
+                # a message queue or socket communication
+                time.sleep(1)
+
+            except Exception as e:
+                logger.error(f"Error in main loop: {e}")
+                time.sleep(5)
+
+    def status(self) -> Dict[str, Any]:
+        """Get daemon status"""
+        is_running = False
+        pid = None
+
+        if self.pid_file.exists():
+            try:
+                with open(self.pid_file, "r") as f:
+                    pid = int(f.read().strip())
+                is_running = psutil.pid_exists(pid)
+            except Exception:
+                pass
+
+        return {
+            "running": is_running,
+            "pid": pid,
+            "pid_file": str(self.pid_file),
+            "socket_file": str(self.socket_file),
+        }
+
+
+# Create the daemon command group
+@click.group(name="daemon")
+def daemon():
+    """Daemon service for command management"""
+    pass
+
+
+# Daemon service commands
+@daemon.command()
+@click.option("--config", help="Path to configuration file")
+def start(config: Optional[str]):
+    """Start the daemon service"""
+    service = DaemonService(config)
+    service.start()
+
+
+@daemon.command()
+def stop():
+    """Stop the daemon service"""
+    pid_file = Path.home() / ".local" / "mcli" / "daemon" / "daemon.pid"
+
+    if not pid_file.exists():
+        click.echo("Daemon is not running")
+        return
+
+    try:
+        with open(pid_file, "r") as f:
+            pid = int(f.read().strip())
+
+        # Send SIGTERM
+        os.kill(pid, signal.SIGTERM)
+        click.echo(f"Sent stop signal to daemon (PID {pid})")
+
+        # Wait a bit and check if it stopped
+        time.sleep(2)
+        if not psutil.pid_exists(pid):
+            click.echo("Daemon stopped successfully")
+        else:
+            click.echo("Daemon may still be running")
+
+    except Exception as e:
+        click.echo(f"Error stopping daemon: {e}")
+
+
+@daemon.command()
+def status():
+    """Show daemon status"""
+    service = DaemonService()
+    status_info = service.status()
+
+    if status_info["running"]:
+        click.echo(f"✅ Daemon is running (PID: {status_info['pid']})")
+    else:
+        click.echo("❌ Daemon is not running")
+
+    click.echo(f"PID file: {status_info['pid_file']}")
+    click.echo(f"Socket file: {status_info['socket_file']}")
+
+
+# Client commands
+@daemon.command()
+@click.argument("name")
+@click.argument("file_path", type=click.Path(exists=True))
+@click.option("--description", help="Command description")
+@click.option(
+    "--language",
+    type=click.Choice(["python", "node", "lua", "shell", "auto"]),
+    default="auto",
+    help="Programming language",
+)
+@click.option("--group", help="Command group")
+@click.option("--tags", help="Comma-separated tags")
+def add_file(name: str, file_path: str, description: str, language: str, group: str, tags: str):
+    """Add a command from a file"""
+    db = CommandDatabase()
+
+    # Read code from file
+    with open(file_path, "r") as f:
+        code_content = f.read()
+
+    # Parse tags
+    tag_list = [tag.strip() for tag in tags.split(",")] if tags else []
+
+    # Create command
+    command = Command(
+        id=str(uuid.uuid4()),
+        name=name,
+        description=description or "",
+        code=code_content,
+        language=language,
+        group=group,
+        tags=tag_list,
+    )
+
+    # Add to database
+    command_id = db.add_command(command)
+    click.echo(f"✅ Command '{name}' added with ID: {command_id}")
+
+
+@daemon.command()
+@click.argument("name")
+@click.option("--description", help="Command description")
+@click.option(
+    "--language",
+    type=click.Choice(["python", "node", "lua", "shell"]),
+    default="python",
+    help="Programming language",
+)
+@click.option("--group", help="Command group")
+@click.option("--tags", help="Comma-separated tags")
+def add_stdin(name: str, description: str, language: str, group: str, tags: str):
+    """Add a command from stdin"""
+    db = CommandDatabase()
+
+    # Parse tags
+    tag_list = [tag.strip() for tag in tags.split(",")] if tags else []
+
+    click.echo("Enter your code (Ctrl+D when done):")
+
+    # Read from stdin
+    lines = []
+    try:
+        while True:
+            line = input()
+            lines.append(line)
+    except EOFError:
+        pass
+
+    code = "\n".join(lines)
+
+    if not code.strip():
+        click.echo("No code provided", err=True)
+        return
+
+    # Create command
+    command = Command(
+        id=str(uuid.uuid4()),
+        name=name,
+        description=description or "",
+        code=code,
+        language=language,
+        group=group,
+        tags=tag_list,
+    )
+
+    # Add to database
+    command_id = db.add_command(command)
+    click.echo(f"✅ Command '{name}' added with ID: {command_id}")
+
+
+@daemon.command()
+def add_interactive():
+    """Add a command interactively"""
+    db = CommandDatabase()
+
+    # Get command name
+    name = click.prompt("Command name", type=str)
+
+    # Check if name already exists
+    existing = db.search_commands(name, limit=1)
+    if existing and existing[0].name == name:
+        if not click.confirm(f"Command '{name}' already exists. Overwrite?"):
+            click.echo("Command creation cancelled")
+            return
+
+    # Get description
+    description = click.prompt("Description (optional)", type=str, default="")
+
+    # Get language
+    language = click.prompt(
+        "Language", type=click.Choice(["python", "node", "lua", "shell"]), default="python"
+    )
+
+    # Get group
+    group = click.prompt("Group (optional)", type=str, default="")
+    if not group:
+        group = None
+
+    # Get tags
+    tags_input = click.prompt("Tags (comma-separated, optional)", type=str, default="")
+    tags = [tag.strip() for tag in tags_input.split(",")] if tags_input else []
+
+    # Get code source
+    source = click.prompt(
+        "Code source", type=click.Choice(["file", "stdin", "paste"]), default="paste"
+    )
+
+    if source == "file":
+        file_path = click.prompt("File path", type=click.Path(exists=True))
+        with open(file_path, "r") as f:
+            code = f.read()
+    elif source == "stdin":
+        click.echo("Enter your code (Ctrl+D when done):")
+        lines = []
+        try:
+            while True:
+                line = input()
+                lines.append(line)
+        except EOFError:
+            pass
+        code = "\n".join(lines)
+    else:  # paste
+        click.echo("Paste your code below (Ctrl+D when done):")
+        lines = []
+        try:
+            while True:
+                line = input()
+                lines.append(line)
+        except EOFError:
+            pass
+        code = "\n".join(lines)
+
+    if not code.strip():
+        click.echo("No code provided", err=True)
+        return
+
+    # Create command
+    command = Command(
+        id=str(uuid.uuid4()),
+        name=name,
+        description=description or "",
+        code=code,
+        language=language,
+        group=group,
+        tags=tags,
+    )
+
+    # Add to database
+    command_id = db.add_command(command)
+    click.echo(f"✅ Command '{name}' added with ID: {command_id}")
+
+
+@daemon.command()
+@click.argument("command_id")
+@click.argument("args", nargs=-1)
+def execute(command_id: str, args: List[str]):
+    """Execute a command"""
+    db = CommandDatabase()
+    executor = CommandExecutor()
+
+    # Get command
+    command = db.get_command(command_id)
+    if not command:
+        click.echo(f"Command '{command_id}' not found", err=True)
+        return
+
+    # Execute
+    result = executor.execute_command(command, list(args))
+
+    # Record execution
+    db.record_execution(
+        command_id=command_id,
+        status=result["status"],
+        output=result.get("output", ""),
+        error=result.get("error", ""),
+        execution_time_ms=result.get("execution_time_ms", 0),
+    )
+
+    # Display results
+    if result["success"]:
+        click.echo("✅ Command executed successfully")
+        if result["output"]:
+            click.echo("Output:")
+            click.echo(result["output"])
+    else:
+        click.echo("❌ Command execution failed")
+        if result["error"]:
+            click.echo(f"Error: {result['error']}")
+
+    click.echo(f"Execution time: {result.get('execution_time_ms', 0)}ms")
+
+
+@daemon.command()
+@click.argument("query")
+@click.option("--limit", default=10, help="Maximum number of results")
+@click.option("--similar", is_flag=True, help="Use similarity search")
+def search(query: str, limit: int, similar: bool):
+    """Search for commands"""
+    db = CommandDatabase()
+
+    try:
+        if similar:
+            results = db.find_similar_commands(query, limit)
+            if results:
+                click.echo(f"Found {len(results)} similar command(s):")
+                for cmd, similarity in results:
+                    click.echo(f"  {cmd.name} ({cmd.language}) - {cmd.description}")
+                    click.echo(f"    Similarity: {similarity:.3f}")
+                    if cmd.tags:
+                        click.echo(f"    Tags: {', '.join(cmd.tags)}")
+                    click.echo()
+            else:
+                click.echo("No similar commands found")
+        else:
+            commands = db.search_commands(query, limit)
+            if commands:
+                click.echo(f"Found {len(commands)} command(s):")
+                for cmd in commands:
+                    click.echo(f"  {cmd.name} ({cmd.language}) - {cmd.description}")
+                    if cmd.tags:
+                        click.echo(f"    Tags: {', '.join(cmd.tags)}")
+                    click.echo()
+            else:
+                click.echo("No commands found")
+
+    except Exception as e:
+        click.echo(f"❌ Error searching commands: {e}", err=True)
+
+
+@daemon.command()
+@click.option("--group", help="Filter by group")
+@click.option("--language", help="Filter by language")
+def list(group: str, language: str):
+    """List all commands"""
+    db = CommandDatabase()
+
+    try:
+        commands = db.get_all_commands()
+
+        # Apply filters
+        if group:
+            commands = [cmd for cmd in commands if cmd.group == group]
+        if language:
+            commands = [cmd for cmd in commands if cmd.language == language]
+
+        if not commands:
+            click.echo("No commands found")
+            return
+
+        click.echo(f"Found {len(commands)} command(s):")
+        for cmd in commands:
+            click.echo(f"  {cmd.name} ({cmd.language}) - {cmd.description}")
+            if cmd.group:
+                click.echo(f"    Group: {cmd.group}")
+            if cmd.tags:
+                click.echo(f"    Tags: {', '.join(cmd.tags)}")
+            click.echo(f"    Executed {cmd.execution_count} times")
+            click.echo()
+
+    except Exception as e:
+        click.echo(f"❌ Error listing commands: {e}", err=True)
+
+
+@daemon.command()
+@click.argument("command_id")
+def show(command_id: str):
+    """Show command details"""
+    db = CommandDatabase()
+
+    try:
+        command = db.get_command(command_id)
+        if not command:
+            click.echo(f"Command '{command_id}' not found", err=True)
+            return
+
+        click.echo(f"Command: {command.name}")
+        click.echo(f"ID: {command.id}")
+        click.echo(f"Description: {command.description}")
+        click.echo(f"Language: {command.language}")
+        if command.group:
+            click.echo(f"Group: {command.group}")
+        if command.tags:
+            click.echo(f"Tags: {', '.join(command.tags)}")
+        click.echo(f"Created: {command.created_at}")
+        click.echo(f"Updated: {command.updated_at}")
+        click.echo(f"Executed: {command.execution_count} times")
+        if command.last_executed:
+            click.echo(f"Last executed: {command.last_executed}")
+        click.echo()
+        click.echo("Code:")
+        click.echo("=" * 50)
+        click.echo(command.code)
+        click.echo("=" * 50)
+
+    except Exception as e:
+        click.echo(f"❌ Error showing command: {e}", err=True)
+
+
+@daemon.command()
+@click.argument("command_id")
+def delete(command_id: str):
+    """Delete a command"""
+    db = CommandDatabase()
+
+    try:
+        command = db.get_command(command_id)
+        if not command:
+            click.echo(f"Command '{command_id}' not found", err=True)
+            return
+
+        if click.confirm(f"Are you sure you want to delete command '{command.name}'?"):
+            if db.delete_command(command_id):
+                click.echo(f"✅ Command '{command.name}' deleted")
+            else:
+                click.echo(f"❌ Error deleting command '{command.name}'")
+        else:
+            click.echo("Deletion cancelled")
+
+    except Exception as e:
+        click.echo(f"❌ Error deleting command: {e}", err=True)
+
+
+@daemon.command()
+@click.argument("command_id")
+@click.option("--name", help="New name")
+@click.option("--description", help="New description")
+@click.option("--group", help="New group")
+@click.option("--tags", help="New tags (comma-separated)")
+def edit(command_id: str, name: str, description: str, group: str, tags: str):
+    """Edit a command"""
+    db = CommandDatabase()
+
+    try:
+        command = db.get_command(command_id)
+        if not command:
+            click.echo(f"Command '{command_id}' not found", err=True)
+            return
+
+        # Update fields if provided
+        if name:
+            command.name = name
+        if description:
+            command.description = description
+        if group:
+            command.group = group
+        if tags:
+            command.tags = [tag.strip() for tag in tags.split(",")]
+
+        command.updated_at = datetime.now()
+
+        if db.update_command(command):
+            click.echo(f"✅ Command '{command.name}' updated")
+        else:
+            click.echo(f"❌ Error updating command '{command.name}'")
+
+    except Exception as e:
+        click.echo(f"❌ Error editing command: {e}", err=True)
+
+
+@daemon.command()
+def groups():
+    """List all command groups"""
+    db = CommandDatabase()
+
+    try:
+        commands = db.get_all_commands()
+        groups = {}
+
+        for cmd in commands:
+            group = cmd.group or "ungrouped"
+            if group not in groups:
+                groups[group] = []
+            groups[group].append(cmd)
+
+        if not groups:
+            click.echo("No groups found")
+            return
+
+        click.echo("Command groups:")
+        for group_name, group_commands in groups.items():
+            click.echo(f"  {group_name} ({len(group_commands)} commands)")
+            for cmd in group_commands:
+                click.echo(f"    - {cmd.name} ({cmd.language})")
+            click.echo()
+
+    except Exception as e:
+        click.echo(f"❌ Error listing groups: {e}", err=True)
+
+
+if __name__ == "__main__":
+    daemon()