shellmate-cli 3.0.0__py3-none-any.whl

shellmate/config/paths.py

@@ -0,0 +1,77 @@
+import os
+import sys
+from pathlib import Path
+
+
+def get_config_dir() -> Path:
+    """Get platform-specific config directory following XDG/AppData conventions."""
+    if sys.platform == "win32":
+        base = os.environ.get("APPDATA")
+        if base:
+            return Path(base) / "ShellMate"
+        return Path.home() / "AppData" / "Roaming" / "ShellMate"
+    else:
+        xdg = os.environ.get("XDG_CONFIG_HOME")
+        if xdg:
+            return Path(xdg) / "shellmate"
+        return Path.home() / ".config" / "shellmate"
+
+
+def get_state_dir() -> Path:
+    """Get platform-specific state/data directory following XDG/AppData conventions."""
+    if sys.platform == "win32":
+        base = os.environ.get("LOCALAPPDATA")
+        if base:
+            return Path(base) / "ShellMate"
+        return Path.home() / "AppData" / "Local" / "ShellMate"
+    else:
+        xdg = os.environ.get("XDG_STATE_HOME")
+        if xdg:
+            return Path(xdg) / "shellmate"
+        return Path.home() / ".local" / "state" / "shellmate"
+
+
+def get_cache_dir() -> Path:
+    """Get platform-specific cache directory following XDG/AppData conventions."""
+    if sys.platform == "win32":
+        base = os.environ.get("LOCALAPPDATA")
+        if base:
+            return Path(base) / "ShellMate" / "cache"
+        return Path.home() / "AppData" / "Local" / "ShellMate" / "cache"
+    else:
+        xdg = os.environ.get("XDG_CACHE_HOME")
+        if xdg:
+            return Path(xdg) / "shellmate"
+        return Path.home() / ".cache" / "shellmate"
+
+
+def get_log_dir() -> Path:
+    """Get platform-specific log directory."""
+    return get_state_dir() / "logs"
+
+
+def get_session_dir() -> Path:
+    """Get platform-specific session directory."""
+    return get_state_dir() / "sessions"
+
+
+def ensure_dirs():
+    """Create all necessary directories with appropriate permissions."""
+    dirs = [
+        get_config_dir(),
+        get_state_dir(),
+        get_cache_dir(),
+        get_log_dir(),
+        get_session_dir(),
+    ]
+    for d in dirs:
+        d.mkdir(parents=True, exist_ok=True)
+        if sys.platform != "win32":
+            try:
+                d.chmod(0o700)
+            except OSError:
+                pass
+
+
+CONFIG_FILE = get_config_dir() / "config.yaml"
+CREDENTIALS_FILE = get_config_dir() / ".env"

shellmate/config/secrets.py

@@ -0,0 +1,66 @@
+import os
+import re
+from typing import Any, Dict, List, Union
+
+
+SECRET_PATTERNS = [
+    (re.compile(r'(api[_-]?key|apikey|secret|token|password|passwd|auth[_-]?token)\s*[:=]\s*["\']?([a-zA-Z0-9_\-]{8,})["\']?', re.IGNORECASE), r'\1=****'),
+    (re.compile(r'(gh[po]_[a-zA-Z0-9]{16,})'), r'****'),
+    (re.compile(r'(sk-[a-zA-Z0-9]{16,})'), r'****'),
+    (re.compile(r'(xox[baprs]-[a-zA-Z0-9\-]{20,})'), r'****'),
+    (re.compile(r'(Bearer\s+[a-zA-Z0-9\._\-]{8,})', re.IGNORECASE), r'Bearer ****'),
+    (re.compile(r'(Authorization:\s*Bearer\s+[a-zA-Z0-9\._\-]{8,})', re.IGNORECASE), r'Authorization: Bearer ****'),
+    (re.compile(r'(Authorization:\s*[\'"]Bearer\s+[a-zA-Z0-9\._\-]{8,})', re.IGNORECASE), r"Authorization: 'Bearer ****"),
+    (re.compile(r'(ssh-rsa\s+[a-zA-Z0-9\/\+\=]{20,})', re.IGNORECASE), r'ssh-rsa ****'),
+    (re.compile(r'(ssh-ed25519\s+[a-zA-Z0-9\+\=]{20,})', re.IGNORECASE), r'ssh-ed25519 ****'),
+    (re.compile(r'([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})'), r'****@****'),
+]
+
+
+def redact_secrets(text: str) -> str:
+    if not isinstance(text, str):
+        return text
+    result = text
+    for pattern, replacement in SECRET_PATTERNS:
+        result = pattern.sub(replacement, result)
+    return result
+
+
+def redact_dict(data: Dict[str, Any], keys_to_redact: List[str] = None) -> Dict[str, Any]:
+    if keys_to_redact is None:
+        keys_to_redact = ['api_key', 'apikey', 'secret', 'token', 'password', 'passwd', 'auth_token', 'authorization']
+
+    result = {}
+    for key, value in data.items():
+        if key.lower() in [k.lower() for k in keys_to_redact]:
+            if isinstance(value, str) and value:
+                result[key] = "****"
+            else:
+                result[key] = "****"
+        elif isinstance(value, dict):
+            result[key] = redact_dict(value, keys_to_redact)
+        elif isinstance(value, list):
+            result[key] = [redact_dict(item, keys_to_redact) if isinstance(item, dict) else redact_secrets(str(item)) if isinstance(item, str) else item for item in value]
+        elif isinstance(value, str):
+            result[key] = redact_secrets(value)
+        else:
+            result[key] = value
+    return result
+
+
+def sanitize_for_logging(data: Any) -> Any:
+    if isinstance(data, dict):
+        return redact_dict(data)
+    elif isinstance(data, list):
+        return [sanitize_for_logging(item) for item in data]
+    elif isinstance(data, str):
+        return redact_secrets(data)
+    return data
+
+
+def sanitize_prompt(prompt: str) -> str:
+    return redact_secrets(prompt)
+
+
+def sanitize_response(response: Any) -> Any:
+    return sanitize_for_logging(response)

shellmate/daemon/lifecycle.py

@@ -0,0 +1,308 @@
+import os
+import signal
+import socket
+import subprocess
+import sys
+import time
+import json
+from shellmate.config.defaults import get_default_config
+from shellmate.daemon.session import (
+    create_session, read_session, remove_session,
+    cleanup_stale_sessions, validate_session_ownership,
+    get_session_dir_path, is_process_alive
+)
+
+
+def _check_port_in_use(host: str, port: int) -> bool:
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.settimeout(1)
+            result = s.connect_ex((host, port))
+            return result == 0
+    except Exception:
+        return False
+
+
+def _query_daemon_status(host, port):
+    """Synchronously query daemon /status, return data dict or None."""
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.settimeout(2)
+        s.connect((host, port))
+        message = json.dumps({"command": "/status", "request_id": "lifecycle"})
+        s.sendall(message.encode("utf-8"))
+        data = s.recv(4096)
+        s.close()
+        result = json.loads(data.decode("utf-8"))
+        if isinstance(result, dict) and result.get("status") == "ok":
+            return result.get("data", {})
+    except Exception:
+        pass
+    return None
+
+
+def _is_shellmate_status(status_data):
+    return bool(status_data and "startup_stage" in status_data)
+
+
+def _find_pid_listening_on_port(host: str, port: int):
+    try:
+        import psutil
+
+        for conn in psutil.net_connections(kind="tcp"):
+            if not conn.laddr or conn.laddr.port != port:
+                continue
+            if conn.status != psutil.CONN_LISTEN:
+                continue
+            if host in ("0.0.0.0", "127.0.0.1", "::1", "::"):
+                if conn.laddr.ip in ("0.0.0.0", "127.0.0.1", "::", "::1", host):
+                    return conn.pid
+            elif conn.laddr.ip == host:
+                return conn.pid
+    except Exception:
+        pass
+
+    if sys.platform == "win32":
+        try:
+            result = subprocess.run(
+                ["netstat", "-ano"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            for line in result.stdout.splitlines():
+                if f"{host}:{port}" in line and "LISTENING" in line:
+                    parts = line.split()
+                    if parts:
+                        return int(parts[-1])
+        except Exception:
+            pass
+    return None
+
+
+def _resolve_daemon_pid(host: str, port: int, status_data):
+    if status_data and status_data.get("daemon_pid"):
+        return status_data["daemon_pid"]
+    return _find_pid_listening_on_port(host, port)
+
+
+def _send_daemon_shutdown(host, port):
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.settimeout(2)
+        s.connect((host, port))
+        message = json.dumps({"command": "shutdown", "request_id": "lifecycle"})
+        s.sendall(message.encode("utf-8"))
+        s.recv(1024)
+        s.close()
+        return True
+    except Exception:
+        return False
+
+
+def _check_daemon_status(host, port):
+    status_data = _query_daemon_status(host, port)
+    if status_data:
+        return status_data.get("startup_stage") == "ready"
+    return False
+
+
+def _wait_for_daemon_ready(pid: int, host: str, port: int, timeout: float = 15.0) -> bool:
+    start = time.time()
+    while time.time() - start < timeout:
+        if not is_process_alive(pid):
+            return False
+        if _check_port_in_use(host, port) and _check_daemon_status(host, port):
+            return True
+        time.sleep(0.3)
+    return is_process_alive(pid) and _check_port_in_use(host, port)
+
+
+def print_provider_warnings():
+    """Relay the daemon's startup provider warnings to the console.
+
+    For callers that start the daemon with wait_ready=False (the `sm enable`
+    Live-scene path), which bypasses the print inside start_daemon. Safe to call
+    once the daemon has reached ready — the check runs before the ready stage.
+    """
+    config = get_default_config()
+    _print_provider_warnings(config["daemon"]["host"], config["daemon"]["port"])
+
+
+def _print_provider_warnings(host, port):
+    """Print any non-fatal provider warnings the daemon raised at startup.
+
+    The daemon runs with its stdout discarded, so the warning is relayed to the
+    user here (the stage that sets it runs before `ready`, so status already
+    carries it by the time we land here).
+    """
+    status_data = _query_daemon_status(host, port)
+    for warning in (status_data or {}).get("provider_warnings", []) or []:
+        message = warning.get("message") if isinstance(warning, dict) else str(warning)
+        if message:
+            # Plain ASCII marker: this prints to the user's console, which may be
+            # cp1252 (classic Windows), where a unicode glyph would raise.
+            print(f"WARNING: {message}")
+
+
+def start_daemon(*, wait_ready: bool = True):
+    """Spawn the ShellMate daemon.
+
+    Args:
+        wait_ready: If True (default), block until startup_stage == ready.
+            If False, return as soon as the process is spawned so the caller
+            (startup UI) can animate live stage progress.
+    """
+    config = get_default_config()
+    host = config["daemon"]["host"]
+    port = config["daemon"]["port"]
+
+    cleanup_stale_sessions()
+
+    session = read_session()
+    if session and is_process_alive(session.get("pid", 0)):
+        if validate_session_ownership(session):
+            print("ShellMate daemon is already running.")
+            return False
+        else:
+            print("Stale session from different user, cleaning up.")
+            remove_session()
+
+    if _check_port_in_use(host, port):
+        status_data = _query_daemon_status(host, port)
+        if _is_shellmate_status(status_data):
+            daemon_pid = _resolve_daemon_pid(host, port, status_data)
+            if daemon_pid:
+                cwd = os.getcwd()
+                ipc_address = f"{host}:{port}"
+                create_session(daemon_pid, cwd, ipc_address)
+                print(f"ShellMate daemon already running (PID: {daemon_pid})")
+                return True
+        print(f"Port {port} is already in use. Is another ShellMate daemon running?")
+        print("Run 'sm disable' first or kill the process holding the port.")
+        return False
+
+    session_dir = get_session_dir_path()
+    session_dir.mkdir(parents=True, exist_ok=True)
+
+    ipc_address = f"{host}:{port}"
+
+    if sys.platform == "win32":
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        process = subprocess.Popen(
+            [sys.executable, "-c", "from shellmate.daemon.server import run_daemon; run_daemon()"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            startupinfo=startupinfo,
+            creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,
+        )
+    else:
+        process = subprocess.Popen(
+            [sys.executable, "-c", "from shellmate.daemon.server import run_daemon; run_daemon()"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+
+    cwd = os.getcwd()
+    create_session(process.pid, cwd, ipc_address)
+
+    if not wait_ready:
+        # UI owns the wait + stage animation
+        print(f"ShellMate daemon starting (PID: {process.pid})")
+        return True
+
+    ready = _wait_for_daemon_ready(process.pid, host, port, timeout=15.0)
+
+    if ready:
+        print(f"ShellMate daemon started (PID: {process.pid})")
+        _print_provider_warnings(host, port)
+    else:
+        print(f"ShellMate daemon process started (PID: {process.pid}) but not yet ready.")
+        print("Run 'sm status' to check the daemon state.")
+
+    return True
+
+
+def stop_daemon():
+    config = get_default_config()
+    host = config["daemon"]["host"]
+    port = config["daemon"]["port"]
+
+    session = read_session()
+    pid = session.get("pid") if session else None
+
+    if not pid and _check_port_in_use(host, port):
+        status_data = _query_daemon_status(host, port)
+        if _is_shellmate_status(status_data):
+            pid = _resolve_daemon_pid(host, port, status_data)
+
+    if not pid:
+        print("ShellMate daemon is not running.")
+        return
+
+    try:
+        if _check_port_in_use(host, port):
+            _send_daemon_shutdown(host, port)
+
+        if sys.platform == "win32":
+            subprocess.run(["taskkill", "/F", "/PID", str(pid)], capture_output=True, timeout=5)
+        else:
+            try:
+                os.kill(pid, signal.SIGTERM)
+                try:
+                    os.waitpid(pid, 0)
+                except ChildProcessError:
+                    pass
+            except (ProcessLookupError, PermissionError):
+                pass
+
+            for _ in range(10):
+                if not is_process_alive(pid):
+                    break
+                time.sleep(0.2)
+            if is_process_alive(pid):
+                try:
+                    os.kill(pid, signal.SIGKILL)
+                except (ProcessLookupError, PermissionError):
+                    pass
+    except Exception as e:
+        print(f"Warning: {e}")
+
+    remove_session()
+    print("ShellMate daemon stopped.")
+
+
+def check_daemon_status():
+    session = read_session()
+    if session and is_process_alive(session.get("pid", 0)):
+        return {
+            "status": "running",
+            "pid": session.get("pid"),
+            "cwd": session.get("cwd"),
+            "created": session.get("created"),
+            "ipc_address": session.get("ipc_address"),
+            "owner": session.get("owner"),
+        }
+    return {
+        "status": "stopped",
+        "pid": None,
+    }
+
+
+def tail_logs():
+    from shellmate.config.defaults import get_default_config
+    config = get_default_config()
+    log_dir = config["logging"]["directory"]
+    log_file = os.path.join(log_dir, "daemon.log")
+    if not os.path.exists(log_file):
+        print("No logs found.")
+        return
+    try:
+        with open(log_file, "r") as f:
+            lines = f.readlines()
+            for line in lines[-50:]:
+                print(line.rstrip())
+    except OSError as e:
+        print(f"Error reading logs: {e}")

shellmate/daemon/observability.py

@@ -0,0 +1,82 @@
+import json
+import logging
+import os
+import time
+from datetime import datetime
+from shellmate.config.defaults import SHELLMATE_DIR
+
+logger = logging.getLogger("shellmate.observability")
+
+METRICS_FILE = os.path.join(SHELLMATE_DIR, "metrics.json")
+
+
+def track_event(event_type, data=None):
+    entry = {
+        "event": event_type,
+        "timestamp": datetime.now().isoformat(),
+        "data": data or {},
+    }
+    logger.debug(json.dumps(entry))
+    return entry
+
+
+def track_latency(stage, duration_ms):
+    entry = {
+        "event": "latency",
+        "stage": stage,
+        "duration_ms": round(duration_ms, 2),
+        "timestamp": datetime.now().isoformat(),
+    }
+    logger.debug(json.dumps(entry))
+    return entry
+
+
+def update_metrics(metric_data):
+    os.makedirs(os.path.dirname(METRICS_FILE), exist_ok=True)
+    metrics = {}
+    if os.path.exists(METRICS_FILE):
+        try:
+            with open(METRICS_FILE, "r") as f:
+                metrics = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    for key, value in metric_data.items():
+        if key not in metrics:
+            metrics[key] = []
+        metrics[key].append({
+            "value": value,
+            "timestamp": datetime.now().isoformat(),
+        })
+        if len(metrics[key]) > 1000:
+            metrics[key] = metrics[key][-1000:]
+
+    try:
+        with open(METRICS_FILE, "w") as f:
+            json.dump(metrics, f, indent=2)
+    except OSError:
+        pass
+
+
+def get_metrics_summary():
+    if not os.path.exists(METRICS_FILE):
+        return {"error": "No metrics data available"}
+
+    try:
+        with open(METRICS_FILE, "r") as f:
+            metrics = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return {"error": "Could not read metrics"}
+
+    summary = {}
+    for key, entries in metrics.items():
+        if entries:
+            values = [e["value"] for e in entries]
+            summary[key] = {
+                "count": len(values),
+                "min": round(min(values), 2),
+                "max": round(max(values), 2),
+                "avg": round(sum(values) / len(values), 2),
+            }
+
+    return summary

shellmate/daemon/pipeline.py

@@ -0,0 +1,119 @@
+import asyncio
+import time
+import logging
+from shellmate.parser.command_parser import parse_command
+from shellmate.sanitizer.typo_detector import sanitize
+from shellmate.rules.engine import load_rules, match_rule
+from shellmate.cache.semantic_cache import cache_lookup, cache_store
+from shellmate.providers.router import analyze_risk, generate_remediation
+from documentation.context7_client import retrieve_documentation_async, should_retrieve_documentation
+from shellmate.config.defaults import get_default_config
+
+logger = logging.getLogger("shellmate.pipeline")
+
+_rules = None
+
+
+def _get_rules():
+    global _rules
+    if _rules is None:
+        _rules = load_rules()
+    return _rules
+
+
+async def run_pipeline_async(command):
+    """Run analysis using the modern graph-based approach with FAISS caching."""
+    try:
+        from shellmate.orchestration.analysis_graph import get_analysis_graph
+        graph = get_analysis_graph()
+        return await graph.analyze_command(command)
+    except (ImportError, Exception) as e:
+        logger.error(f"Failed to run analysis graph: {e}")
+        # Return minimal safe response
+        return _build_response(
+            risk="UNKNOWN",
+            confidence=0.0,
+            message="Analysis temporarily unavailable",
+            explanation=str(e),
+            stages={},
+        )
+
+
+# Legacy pipeline removed - using graph-based analysis with FAISS cache only
+
+def _needs_context(command: str) -> bool:
+    tokens = command.split()
+    if not tokens:
+        return False
+    cmd = tokens[0].lower()
+    if cmd in ("rm", "mv", "cp", "cat", "less", "nano", "vim", "vi", "code", "open"):
+        return True
+    for token in tokens:
+        if token.startswith(("./", "../", "/", ".\\", "..\\")):
+            return True
+    if cmd in ("git", "docker", "docker-compose", "pip", "npm", "yarn", "pnpm"):
+        return True
+    return False
+
+
+def run_pipeline(command):
+    """Synchronous wrapper - deprecated, use run_pipeline_async."""
+    logger.warning("run_pipeline() is deprecated, use run_pipeline_async()")
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = None
+    
+    if loop and loop.is_running():
+        # We're in an async context, run as a task
+        import concurrent.futures
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future = executor.submit(asyncio.run, run_pipeline_async(command))
+            return future.result()
+    else:
+        return asyncio.run(run_pipeline_async(command))
+
+
+RISK_ORDER = {"SAFE": 0, "LOW": 1, "MEDIUM": 2, "HIGH": 3, "CRITICAL": 4}
+
+
+def _build_response(
+    risk="MEDIUM",
+    confidence=0.5,
+    message="",
+    explanation="",
+    alternatives=None,
+    context_used=None,
+    rule_id=None,
+    category=None,
+    cached=False,
+    documentation=None,
+    rule_match=None,
+    risk_analysis=None,
+    stages=None,
+    early_exit=None,
+):
+    result = {
+        "risk": risk,
+        "confidence": confidence,
+        "message": message,
+        "explanation": explanation,
+        "alternatives": alternatives or [],
+        "cached": cached,
+    }
+
+    if context_used:
+        result["context_used"] = context_used
+    if rule_id:
+        result["rule_id"] = rule_id
+    if category:
+        result["category"] = category
+    if documentation:
+        result["documentation"] = documentation
+    if early_exit:
+        result["early_exit"] = early_exit
+    if stages:
+        result["latency"] = {k: round(v * 1000, 2) for k, v in stages.items()}
+        result["total_ms"] = round(sum(stages.values()) * 1000, 2)
+
+    return result