shellmate-cli 3.0.0__py3-none-any.whl

shellmate/cli/parser.py

@@ -0,0 +1,184 @@
+import sys
+import re
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict
+from enum import Enum
+
+
+class ExitCode(Enum):
+    SUCCESS = 0
+    USAGE_ERROR = 2
+    TEMP_ERROR = 3
+    INTERNAL_ERROR = 4
+
+
+class Action(Enum):
+    ENABLE = "enable"
+    DISABLE = "disable"
+    STATUS = "status"
+    CONFIG = "config"
+    INSTALL = "install"
+    UNINSTALL = "uninstall"
+    HELP = "help"
+    VERSION = "version"
+
+
+@dataclass
+class ParsedCommand:
+    action: Action
+    raw_command: Optional[str] = None
+    tokens: List[str] = None
+    error: Optional[str] = None
+    suggestion: Optional[str] = None
+    exit_code: ExitCode = ExitCode.SUCCESS
+    quiet: bool = False
+    no_color: bool = False
+    dry_run: bool = False
+    verbose: bool = False  # NEW Phase 5 - Task 5.1
+    
+    # NEW v3 fields
+    queries: List[str] = field(default_factory=list)
+    directives: List[str] = field(default_factory=list)
+    overrides: Dict[str, str] = field(default_factory=dict)
+
+    def __post_init__(self):
+        if self.tokens is None:
+            self.tokens = []
+
+
+_SUBCOMMANDS = frozenset({
+    "enable", "disable", "status", "config",
+    "install", "uninstall",
+    "-h", "--help", "-v", "--version",
+})
+
+
+def _extract_bracket_syntax(command: str) -> tuple:
+    """Extract [?...], [!...], [@...] from command string.
+    
+    Returns:
+        tuple: (cleaned_command, queries, directives, overrides)
+    """
+    # Extract queries [?...]
+    queries = re.findall(r'\[\?([^\]]+)\]', command)
+    
+    # Extract directives [!...]
+    directives = re.findall(r'\[!([^\]]+)\]', command)
+    
+    # Extract overrides [@...]
+    overrides_raw = re.findall(r'\[@([^\]]+)\]', command)
+    overrides = {}
+    for override in overrides_raw:
+        if '=' in override:
+            key, value = override.split('=', 1)
+            overrides[key.strip()] = value.strip()
+    
+    # Remove all brackets from command
+    cleaned = re.sub(r'\[[\?!@][^\]]+\]', '', command).strip()
+    
+    return cleaned, queries, directives, overrides
+
+
+class ShellMateCommandParser:
+    def __init__(self, argv: List[str] = None):
+        self.argv = argv or sys.argv[1:]
+
+    def _consume_global_flags(self, args: List[str]):
+        """Parse sm-level flags only before the subcommand.
+
+        Flags that belong to the analyzed shell command (e.g. pytest -q) must
+        not be stripped from argv.
+        """
+        quiet = False
+        no_color = False
+        dry_run = False
+        verbose = False  # NEW Phase 5 - Task 5.1
+        remaining = list(args)
+
+        while remaining and remaining[0] not in _SUBCOMMANDS:
+            flag = remaining.pop(0)
+            if flag in ("--quiet", "-q"):
+                quiet = True
+            elif flag == "--no-color":
+                no_color = True
+            elif flag == "--dry-run":
+                dry_run = True
+            elif flag == "--verbose":
+                verbose = True
+            else:
+                remaining.insert(0, flag)
+                break
+
+        return remaining, quiet, no_color, dry_run, verbose
+
+    def parse(self) -> ParsedCommand:
+        # Bare `sm` (and flag-only argv) → usage help (Done When: sm shows command list)
+        if not self.argv:
+            return ParsedCommand(action=Action.HELP)
+
+        args, quiet, no_color, dry_run, verbose = self._consume_global_flags(self.argv)
+        self._dry_run = dry_run
+
+        if not args:
+            return ParsedCommand(
+                action=Action.HELP,
+                no_color=no_color,
+                dry_run=self._dry_run,
+                verbose=verbose,
+            )
+
+        first_arg = args[0]
+
+        if first_arg in ("-h", "--help"):
+            return ParsedCommand(action=Action.HELP, no_color=no_color, dry_run=self._dry_run, verbose=verbose)
+
+        if first_arg in ("-v", "--version"):
+            return ParsedCommand(action=Action.VERSION, no_color=no_color, dry_run=self._dry_run, verbose=verbose)
+
+        if first_arg in ("enable", "disable", "status", "config", "install", "uninstall"):
+            parsed = self._parse_simple_command(first_arg, args[1:])
+            parsed.no_color = no_color
+            parsed.dry_run = self._dry_run
+            parsed.verbose = verbose
+            return parsed
+
+        if first_arg.endswith(".py") or "test_" in first_arg or "/test" in first_arg or "\\test" in first_arg or "tests/" in first_arg:
+            return ParsedCommand(
+                action=Action.HELP,
+                error="No command provided",
+                suggestion="Run 'sm --help' for usage",
+                exit_code=ExitCode.USAGE_ERROR,
+                no_color=no_color,
+                dry_run=self._dry_run,
+                verbose=verbose,
+            )
+
+        return ParsedCommand(
+            action=Action.HELP,
+            error=f"Unknown command: {first_arg}",
+            suggestion="Run 'sm --help' for usage.",
+            exit_code=ExitCode.USAGE_ERROR,
+            no_color=no_color,
+            dry_run=self._dry_run,
+            verbose=verbose,
+        )
+
+    def _parse_simple_command(self, cmd: str, rest: Optional[List[str]] = None) -> ParsedCommand:
+        action_map = {
+            "enable": Action.ENABLE,
+            "disable": Action.DISABLE,
+            "status": Action.STATUS,
+            "config": Action.CONFIG,
+            "install": Action.INSTALL,
+            "uninstall": Action.UNINSTALL,
+        }
+        parsed = ParsedCommand(action=action_map[cmd])
+        # Stash remaining flags for commands that accept them
+        if rest:
+            parsed.tokens = list(rest)
+        return parsed
+
+
+def parse_argv(argv: List[str] = None) -> ParsedCommand:
+    parser = ShellMateCommandParser(argv)
+    return parser.parse()

shellmate/cli/version.py

@@ -0,0 +1 @@
+VERSION = "3.0.0"

shellmate/completion/__init__.py

@@ -0,0 +1,4 @@
+"""Completion source adapters for autocomplete mode"""
+from shellmate.completion.bash_adapter import get_completions
+
+__all__ = ["get_completions"]

shellmate/completion/bash_adapter.py

@@ -0,0 +1,145 @@
+"""Completion source adapters for autocomplete mode (Phase 4).
+
+Works offline / without bash (Windows) via static subcommand maps,
+then bash compgen, then carapace.
+"""
+
+from __future__ import annotations
+
+import shlex
+import subprocess
+from typing import List
+
+# Shared with ipc/ps_client offline path — keep in sync for ghost-text / Tab.
+_SUBCOMMANDS = {
+    "git": [
+        "status", "push", "pull", "commit", "checkout", "branch", "log", "diff",
+        "add", "merge", "rebase", "reset", "fetch", "clone", "stash", "remote",
+    ],
+    "docker": ["ps", "images", "run", "build", "exec", "stop", "rm", "compose", "logs"],
+    "kubectl": ["get", "apply", "delete", "describe", "logs", "exec", "port-forward"],
+    "npm": ["install", "run", "test", "build", "start", "ci"],
+}
+
+_FLAG_MAP = {
+    "git": ["--force", "--all", "--verbose", "--help", "--amend", "--no-verify"],
+    "docker": ["--help", "--version", "--verbose", "--rm", "-it"],
+    "kubectl": ["--namespace", "--context", "--kubeconfig", "--help"],
+}
+
+
+def get_completions(partial_command: str) -> List[str]:
+    """
+    Get completions for a partial command.
+
+    Order: static map (always available) → bash compgen → carapace.
+    Returns full-line suggestions when completing a subcommand (e.g. "git push")
+    so ble.sh ghost text can strip the typed prefix.
+    """
+    candidates = get_completions_static(partial_command)
+    if candidates:
+        return candidates
+
+    candidates = get_completions_bash(partial_command)
+    if candidates:
+        return candidates
+
+    return get_completions_carapace(partial_command)
+
+
+def get_completions_static(partial_command: str) -> List[str]:
+    """Offline completions from known program maps (Windows-safe)."""
+    partial = (partial_command or "").strip()
+    if not partial:
+        return []
+
+    try:
+        tokens = shlex.split(partial_command)
+    except ValueError:
+        tokens = partial_command.split()
+
+    if not tokens:
+        return []
+
+    program = tokens[0]
+    ends_with_space = partial_command.endswith(" ")
+    current = "" if ends_with_space else tokens[-1]
+
+    # Flag completion
+    if current.startswith("-"):
+        flags = get_flag_completions(program, current)
+        return flags[:10]
+
+    # Program name completion (single token)
+    if len(tokens) == 1 and not ends_with_space:
+        return [p for p in _SUBCOMMANDS if p.startswith(program)][:10]
+
+    # Subcommand completion: "git pu" → ["git push", "git pull"]
+    if program in _SUBCOMMANDS:
+        if len(tokens) == 1 and ends_with_space:
+            prefix = ""
+        elif len(tokens) == 2 and not ends_with_space:
+            prefix = tokens[1]
+        else:
+            return []
+
+        matches = [s for s in _SUBCOMMANDS[program] if s.startswith(prefix)]
+        # Full-line form for adapters; also expose bare subcommands for callers
+        # that expect pivot-style ["push", "pull"].
+        full = [f"{program} {m}" for m in matches]
+        return (full or matches)[:10]
+
+    return []
+
+
+def get_completions_bash(partial_command: str) -> List[str]:
+    """Get bash completions using compgen (Linux/WSL/Git Bash)."""
+    try:
+        tokens = shlex.split(partial_command)
+        if not tokens:
+            return []
+
+        program = tokens[0]
+        current = tokens[-1] if len(tokens) > 1 else program
+
+        # Escape for safe shell interpolation
+        safe_current = current.replace("'", "'\\''")
+        result = subprocess.run(
+            ["bash", "-c", f"compgen -c -- '{safe_current}'"],
+            capture_output=True,
+            text=True,
+            timeout=0.1,
+        )
+
+        if result.returncode == 0 and result.stdout.strip():
+            candidates = [c for c in result.stdout.strip().split("\n") if c]
+            # Prefer candidates that extend the typed token
+            filtered = [c for c in candidates if c.startswith(current)][:10]
+            return filtered
+
+        return []
+    except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+        return []
+
+
+def get_flag_completions(program: str, partial_flag: str) -> List[str]:
+    """Get flag completions for known programs."""
+    flags = _FLAG_MAP.get(program, [])
+    return [f for f in flags if f.startswith(partial_flag)]
+
+
+def get_completions_carapace(partial_command: str) -> List[str]:
+    """Fallback to carapace if bash-completion unavailable."""
+    try:
+        result = subprocess.run(
+            ["carapace", "_carapace", "bash", partial_command],
+            capture_output=True,
+            text=True,
+            timeout=0.2,
+        )
+
+        if result.returncode == 0 and result.stdout.strip():
+            return [c for c in result.stdout.strip().split("\n") if c][:10]
+        return []
+    except (FileNotFoundError, subprocess.TimeoutExpired, Exception):
+        return []

shellmate/config/__init__.py

@@ -0,0 +1,33 @@
+from shellmate.config.defaults import get_default_config, SHELLMATE_DIR
+from shellmate.config.credentials import (
+    CREDENTIAL_KEYS,
+    AI_CREDENTIAL_KEYS,
+    load_env,
+    save_env,
+    get_credential_status,
+    get_api_key,
+    export_script,
+)
+from shellmate.config.manager import get_config, get_config_value, set_config_value, get_config_manager
+from shellmate.config.secrets import redact_secrets, redact_dict, sanitize_for_logging, sanitize_prompt, sanitize_response
+
+__all__ = [
+    "get_default_config",
+    "SHELLMATE_DIR",
+    "CREDENTIAL_KEYS",
+    "AI_CREDENTIAL_KEYS",
+    "load_env",
+    "save_env",
+    "get_credential_status",
+    "get_api_key",
+    "export_script",
+    "get_config",
+    "get_config_value",
+    "set_config_value",
+    "get_config_manager",
+    "redact_secrets",
+    "redact_dict",
+    "sanitize_for_logging",
+    "sanitize_prompt",
+    "sanitize_response",
+]

shellmate/config/credentials.py

@@ -0,0 +1,120 @@
+import os
+import stat
+from pathlib import Path
+from shellmate.config.paths import CREDENTIALS_FILE, ensure_dirs
+
+
+CREDENTIAL_KEYS = {
+    "GROQ_API_KEY": {
+        "label": "Groq API Key",
+        "description": "For AI risk analysis (get at https://console.groq.com/keys)",
+        "doc_url": "https://console.groq.com/keys",
+        "required": False,
+        "provider": "groq",
+        "live_check": True,
+    },
+    "OPENROUTER_API_KEY": {
+        "label": "OpenRouter API Key",
+        "description": "For AI remediation suggestions (get at https://openrouter.ai/keys)",
+        "doc_url": "https://openrouter.ai/keys",
+        "required": False,
+        "provider": "openrouter",
+        "live_check": True,
+    },
+    "XAI_API_KEY": {
+        "label": "Grok (xAI) API Key",
+        "description": "For AI risk analysis and remediation (get at https://console.x.ai/)",
+        "doc_url": "https://console.x.ai/",
+        "required": False,
+        "provider": "xai",
+        "live_check": True,
+    },
+    "CONTEXT7_API_KEY": {
+        "label": "Context7 API Key",
+        "description": "For documentation lookup (get at https://context7.com)",
+        "doc_url": "https://context7.com",
+        "required": False,
+        "provider": "context7",
+        "live_check": False,
+    },
+}
+
+# AI providers that can power risk/remediation (excludes optional Context7)
+AI_CREDENTIAL_KEYS = ("GROQ_API_KEY", "OPENROUTER_API_KEY", "XAI_API_KEY")
+
+
+def load_env() -> dict:
+    if not CREDENTIALS_FILE.exists():
+        return {}
+    env = {}
+    try:
+        with open(CREDENTIALS_FILE, "r") as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                if "=" in line:
+                    key, _, value = line.partition("=")
+                    key = key.strip()
+                    value = value.strip().strip("\"'")
+                    env[key] = value
+    except OSError:
+        pass
+    return env
+
+
+def save_env(env_dict: dict) -> None:
+    ensure_dirs()
+    with open(CREDENTIALS_FILE, "w") as f:
+        f.write("# ShellMate Credentials\n")
+        f.write("# Generated by `sm config`\n")
+        f.write("# Add your API keys below (one per line, KEY=VALUE format)\n\n")
+        for key in CREDENTIAL_KEYS:
+            value = env_dict.get(key, "")
+            if value:
+                f.write(f"{key}={value}\n")
+            else:
+                f.write(f"# {key}=\n")
+
+    if os.name != "nt":
+        try:
+            CREDENTIALS_FILE.chmod(stat.S_IRUSR | stat.S_IWUSR)
+        except OSError:
+            pass
+
+
+def get_credential_status() -> dict:
+    env = load_env()
+    result = {}
+    for key, info in CREDENTIAL_KEYS.items():
+        value = env.get(key, os.environ.get(key, ""))
+        result[key] = {
+            "configured": bool(value),
+            "label": info["label"],
+            "masked": _mask_key(value) if value else None,
+        }
+    return result
+
+
+def get_api_key(key_name: str) -> str:
+    env = load_env()
+    return os.environ.get(key_name, "") or env.get(key_name, "")
+
+
+def _mask_key(key: str) -> str:
+    if len(key) <= 8:
+        return key[:4] + ("*" * (len(key) - 4))
+    return key[:4] + ("*" * (len(key) - 8)) + key[-4:]
+
+
+def export_script(shell: str = "bash") -> str:
+    env = load_env()
+    lines = []
+    for key in CREDENTIAL_KEYS:
+        value = env.get(key)
+        if value:
+            if shell == "powershell":
+                lines.append(f"$env:{key} = '{value}'")
+            else:
+                lines.append(f"export {key}='{value}'")
+    return "\n".join(lines)

shellmate/config/defaults.py

@@ -0,0 +1,88 @@
+import os
+from shellmate.config.paths import get_cache_dir, get_log_dir, get_session_dir, get_state_dir
+
+SHELLMATE_DIR = str(get_state_dir())
+
+
+def get_default_config():
+    return {
+        "daemon": {
+            "host": "127.0.0.1",
+            "port": 9823,
+            "socket_path": str(get_session_dir() / "shellmate.sock"),
+            "pipe_name": r"\\.\pipe\shellmate",
+        },
+        "cache": {
+            "enabled": True,
+            "backend": "faiss",
+            "model": "all-MiniLM-L6-v2",
+            "similarity_threshold": 0.92,
+            "expiration_days": 30,
+            "max_entries": 10000,
+            "directory": str(get_cache_dir()),
+        },
+        "providers": {
+            "risk_analysis": {
+                "primary": "groq",
+                "model": "qwen/qwen3.8-27b",
+                "fallback": None,
+            },
+            "remediation": {
+                "primary": "openrouter",
+                "model": "gpt-4o-mini",
+                "fallbacks": [
+                    "meta-llama/llama-3.3-70b-instruct",
+                    "qwen/qwen2.5-72b-instruct",
+                ],
+            },
+        },
+        "latency_targets": {
+            "cache_hit_ms": 200,
+            "rule_match_ms": 50,
+            "ai_analysis_ms": 5000,
+        },
+        "logging": {
+            "level": "INFO",
+            "directory": str(get_log_dir()),
+            "max_bytes": 10485760,
+            "backup_count": 5,
+        },
+        "supervisor": {
+            "model": os.environ.get("GROQ_SUPERVISOR_MODEL", "qwen/qwen3.8-27b"),
+            "timeout_ms": 500,
+        },
+        "command_guide": {
+            "model": os.environ.get("GROQ_COMMAND_GUIDE_MODEL", "qwen/qwen3.8-27b"),
+            "timeout_ms": int(os.environ.get("GROQ_COMMAND_GUIDE_TIMEOUT_MS", "2000")),
+        },
+        "plugins": {
+            "directory": str(get_session_dir() / "plugins"),
+            "enabled": True,
+        },
+        "overrides_file": str(get_session_dir() / "overrides.json"),
+        "metrics_file": str(get_session_dir() / "metrics.json"),
+        "v3": {
+            "environment": {
+                "business_hours_start": 9,        # 9 AM
+                "business_hours_end": 17,         # 5 PM
+                "timezone": "America/Los_Angeles",
+                "cache_ttl_minutes": 5,
+                "detection_timeout_ms": 30,
+            },
+            "command_history": {
+                "max_commands": 1000,
+                "retention_days": 7,
+                "redact_secrets": True,
+                "secret_patterns": [
+                    r"--password[= ](\S+)",
+                    r"--token[= ](\S+)",
+                    r"export \w*KEY\w*=",
+                ],
+            },
+            "query_processing": {
+                "timeout_ms": 100,
+                "cache_enabled": True,
+                "max_response_length": 500,  # words
+            },
+        },
+    }

shellmate/config/manager.py

@@ -0,0 +1,94 @@
+import os
+import yaml
+from pathlib import Path
+from typing import Any, Dict, Optional
+from shellmate.config.paths import CONFIG_FILE, CREDENTIALS_FILE, ensure_dirs, get_cache_dir, get_log_dir, get_session_dir
+from shellmate.config.defaults import get_default_config
+
+
+class ConfigManager:
+    def __init__(self):
+        self._config: Optional[Dict[str, Any]] = None
+
+    def load(self) -> Dict[str, Any]:
+        if self._config is not None:
+            return self._config
+
+        ensure_dirs()
+        config = get_default_config()
+
+        config["cache"]["directory"] = str(get_cache_dir())
+        config["logging"]["directory"] = str(get_log_dir())
+        config["session_dir"] = str(get_session_dir())
+
+        if CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE, "r") as f:
+                    user_config = yaml.safe_load(f) or {}
+                config = self._deep_merge(config, user_config)
+            except (yaml.YAMLError, OSError):
+                pass
+
+        self._config = config
+        return config
+
+    def _deep_merge(self, base: Dict, override: Dict) -> Dict:
+        result = base.copy()
+        for key, value in override.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = self._deep_merge(result[key], value)
+            else:
+                result[key] = value
+        return result
+
+    def save(self, config: Dict[str, Any]) -> None:
+        ensure_dirs()
+        with open(CONFIG_FILE, "w") as f:
+            yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+        self._config = config
+
+    def get(self, key: str, default=None) -> Any:
+        config = self.load()
+        keys = key.split(".")
+        value = config
+        for k in keys:
+            if isinstance(value, dict):
+                value = value.get(k)
+            else:
+                return default
+            if value is None:
+                return default
+        return value
+
+    def set(self, key: str, value: Any) -> None:
+        config = self.load()
+        keys = key.split(".")
+        target = config
+        for k in keys[:-1]:
+            if k not in target:
+                target[k] = {}
+            target = target[k]
+        target[keys[-1]] = value
+        self.save(config)
+
+
+_config_manager = None
+
+
+def get_config_manager() -> ConfigManager:
+    global _config_manager
+    if _config_manager is None:
+        _config_manager = ConfigManager()
+    return _config_manager
+
+
+def get_config() -> Dict[str, Any]:
+    return get_config_manager().load()
+
+
+def get_config_value(key: str, default=None) -> Any:
+    return get_config_manager().get(key, default)
+
+
+def set_config_value(key: str, value: Any) -> None:
+    get_config_manager().set(key, value)