shellmate-cli 3.0.0__py3-none-any.whl

shellmate/agents/watcher.py

@@ -0,0 +1,266 @@
+import asyncio
+import os
+import platform
+import subprocess
+import sys
+import logging
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+from shellmate.agents.base import Agent, AgentRequest, AgentResponse
+from shellmate.config.secrets import redact_secrets
+
+logger = logging.getLogger("shellmate.agents.watcher")
+
+
+class WatcherAgent(Agent):
+    def __init__(self):
+        super().__init__("watcher")
+        self._cached_context: Optional[Dict[str, Any]] = None
+        self._cache_valid = False
+
+    async def initialize(self) -> None:
+        self._cached_context = await self._gather_context()
+        self._cache_valid = True
+        logger.info("Watcher agent initialized with cached context")
+
+    async def shutdown(self) -> None:
+        self._cached_context = None
+        self._cache_valid = False
+
+    async def process(self, request: AgentRequest) -> AgentResponse:
+        if not self._cache_valid:
+            self._cached_context = await self._gather_context()
+            self._cache_valid = True
+
+        return AgentResponse(
+            request_id=request.request_id,
+            agent_name=self.name,
+            status="ok",
+            data=self._cached_context or {},
+            latency_ms=0.0,
+        )
+
+    async def _gather_context(self) -> Dict[str, Any]:
+        context = {}
+
+        context["os"] = self._detect_os()
+        context["shell"] = self._detect_shell()
+        context["terminal"] = self._detect_terminal()
+        context["environment"] = self._detect_environment()
+        context["interactive"] = self._detect_interactive()
+        context["tech_stack"] = await self._detect_tech_stack()
+        context["git"] = await self._detect_git_context()
+
+        return self._redact_context(context)
+
+    def _detect_os(self) -> Dict[str, Any]:
+        return {
+            "system": platform.system(),
+            "release": platform.release(),
+            "version": platform.version(),
+            "machine": platform.machine(),
+        }
+
+    def _detect_shell(self) -> Optional[str]:
+        shell = os.environ.get("SHELL")
+        if shell:
+            return Path(shell).name
+        if sys.platform == "win32":
+            return os.environ.get("COMSPEC", "cmd.exe").split("\\")[-1]
+        return None
+
+    def _detect_terminal(self) -> Optional[str]:
+        term = os.environ.get("TERM")
+        term_program = os.environ.get("TERM_PROGRAM")
+        if term_program:
+            return term_program
+        if term:
+            return term
+        if sys.platform == "win32":
+            return "windows_console"
+        return None
+
+    def _detect_environment(self) -> Dict[str, bool]:
+        env = {}
+        env["wsl"] = "WSL_DISTRO_NAME" in os.environ or "WSL_INTEROP" in os.environ
+        env["container"] = Path("/.dockerenv").exists() or os.environ.get("CONTAINER") == "true"
+        env["ssh"] = "SSH_CONNECTION" in os.environ or "SSH_CLIENT" in os.environ
+        env["ci"] = any(k in os.environ for k in ["CI", "GITHUB_ACTIONS", "GITLAB_CI", "BUILDKITE"])
+        return env
+
+    def _detect_interactive(self) -> bool:
+        if sys.stdin.isatty():
+            return True
+        if sys.platform == "win32":
+            try:
+                import msvcrt
+                return msvcrt.kbhit() or True
+            except ImportError:
+                pass
+        return False
+
+    async def _detect_tech_stack(self) -> List[str]:
+        cwd = Path.cwd()
+        indicators = []
+
+        checks = [
+            ("package.json", "nodejs"),
+            ("pyproject.toml", "python"),
+            ("requirements.txt", "python"),
+            ("setup.py", "python"),
+            ("Cargo.toml", "rust"),
+            ("go.mod", "go"),
+            ("pom.xml", "java"),
+            ("build.gradle", "java"),
+            ("composer.json", "php"),
+            ("Gemfile", "ruby"),
+            ("mix.exs", "elixir"),
+            ("rebar.config", "erlang"),
+            ("vite.config.ts", "nodejs"),
+            ("vite.config.js", "nodejs"),
+            ("vite.config.mjs", "nodejs"),
+            ("vite.config.cjs", "nodejs"),
+            ("tsconfig.json", "typescript"),
+            ("Makefile", "make"),
+            ("CMakeLists.txt", "cmake"),
+            ("Dockerfile", "docker"),
+            ("docker-compose.yml", "docker"),
+            (".github/workflows", "github_actions"),
+            (".gitlab-ci.yml", "gitlab_ci"),
+        ]
+
+        for path, label in checks:
+            if (cwd / path).exists():
+                indicators.append(label)
+
+        return indicators
+
+    async def _detect_git_context(self) -> Dict[str, Any]:
+        git_info = {
+            "available": False,
+            "is_repo": False,
+            "branch": None,
+            "commit": None,
+            "staged": 0,
+            "unstaged": 0,
+            "remote_url": None,
+            "root": None,
+        }
+
+        try:
+            result = await asyncio.wait_for(
+                asyncio.create_subprocess_exec(
+                    "git", "rev-parse", "--git-dir",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                ),
+                timeout=2.0,
+            )
+            stdout, _ = await result.communicate()
+            if result.returncode != 0:
+                return git_info
+
+            git_info["available"] = True
+            git_info["is_repo"] = True
+
+            root_result = await asyncio.wait_for(
+                asyncio.create_subprocess_exec(
+                    "git", "rev-parse", "--show-toplevel",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                ),
+                timeout=2.0,
+            )
+            stdout, _ = await root_result.communicate()
+            if root_result.returncode == 0:
+                git_info["root"] = stdout.decode().strip()
+
+            branch_result = await asyncio.wait_for(
+                asyncio.create_subprocess_exec(
+                    "git", "branch", "--show-current",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                ),
+                timeout=2.0,
+            )
+            stdout, _ = await branch_result.communicate()
+            if branch_result.returncode == 0:
+                branch = stdout.decode().strip()
+                if branch:
+                    git_info["branch"] = branch
+                else:
+                    commit_result = await asyncio.wait_for(
+                        asyncio.create_subprocess_exec(
+                            "git", "rev-parse", "HEAD",
+                            stdout=asyncio.subprocess.PIPE,
+                            stderr=asyncio.subprocess.PIPE,
+                        ),
+                        timeout=2.0,
+                    )
+                    stdout, _ = await commit_result.communicate()
+                    if commit_result.returncode == 0:
+                        git_info["commit"] = stdout.decode().strip()[:12]
+                        git_info["branch"] = f"detached@{git_info['commit']}"
+
+            status_result = await asyncio.wait_for(
+                asyncio.create_subprocess_exec(
+                    "git", "status", "--porcelain",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                ),
+                timeout=2.0,
+            )
+            stdout, _ = await status_result.communicate()
+            if status_result.returncode == 0:
+                lines = stdout.decode().strip().split("\n") if stdout.decode().strip() else []
+                staged = 0
+                unstaged = 0
+                for line in lines:
+                    if len(line) < 3:
+                        continue
+                    staged_flag = line[0]
+                    unstaged_flag = line[1]
+                    if staged_flag in ("M", "A", "D", "R", "C"):
+                        staged += 1
+                    if unstaged_flag in ("M", "A", "D", "?", "U"):
+                        unstaged += 1
+                git_info["staged"] = staged
+                git_info["unstaged"] = unstaged
+
+            remote_result = await asyncio.wait_for(
+                asyncio.create_subprocess_exec(
+                    "git", "config", "--get", "remote.origin.url",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                ),
+                timeout=2.0,
+            )
+            stdout, _ = await remote_result.communicate()
+            if remote_result.returncode == 0:
+                git_info["remote_url"] = stdout.decode().strip()
+
+        except (asyncio.TimeoutError, FileNotFoundError, OSError):
+            pass
+
+        return git_info
+
+    def _redact_context(self, context: Dict[str, Any]) -> Dict[str, Any]:
+        git = context.get("git", {})
+        if git.get("remote_url"):
+            git["remote_url"] = redact_secrets(git["remote_url"])
+            context["git"] = git
+
+        if context.get("shell"):
+            context["shell"] = redact_secrets(context["shell"])
+
+        return context
+
+
+_watcher_agent: Optional[WatcherAgent] = None
+
+
+def get_watcher_agent() -> WatcherAgent:
+    global _watcher_agent
+    if _watcher_agent is None:
+        _watcher_agent = WatcherAgent()
+    return _watcher_agent

shellmate/cache/semantic_cache.py

@@ -0,0 +1,41 @@
+"""Exact-match command cache. Replaces FAISS semantic cache."""
+
+import threading
+from datetime import datetime, timedelta
+
+_lock = threading.Lock()
+_store: dict = {}
+_EXPIRY_DAYS = 7
+_MAX_ENTRIES = 500
+
+
+def cache_lookup(command: str):
+    with _lock:
+        entry = _store.get(command)
+        if entry is None:
+            return None
+        if datetime.now() - entry["ts"] > timedelta(days=_EXPIRY_DAYS):
+            del _store[command]
+            return None
+        return {**entry["result"], "cached": True}
+
+
+def cache_store(command: str, result: dict):
+    with _lock:
+        if len(_store) >= _MAX_ENTRIES:
+            oldest = min(_store, key=lambda k: _store[k]["ts"])
+            del _store[oldest]
+        _store[command] = {"result": result, "ts": datetime.now()}
+
+
+def preload_embedder_async():
+    pass
+
+
+def wait_for_embedder(timeout=60):
+    return True
+
+
+def clear_cache():
+    with _lock:
+        _store.clear()

shellmate/cli/commands/__init__.py

@@ -0,0 +1,27 @@
+"""CLI commands for ShellMate"""
+from shellmate.cli.commands.analyze import analyze_command
+from shellmate.cli.commands.enable import enable as enable_command
+from shellmate.cli.commands.disable import disable as disable_command
+from shellmate.cli.commands.status import status as status_command
+from shellmate.cli.commands.config import config as config_command
+from shellmate.cli.commands.install import install
+from shellmate.cli.commands.uninstall import uninstall
+from shellmate.cli.commands.configure import configure
+
+# Do not bind `init` / `migrate` / `enable` on this package — that shadows the
+# submodules and breaks `import cli.commands.enable`. Import under aliases.
+from shellmate.cli.commands.init import init as init_command
+from shellmate.cli.commands.migrate import migrate as migrate_command
+
+__all__ = [
+    "analyze_command",
+    "enable_command",
+    "disable_command",
+    "status_command",
+    "config_command",
+    "install",
+    "uninstall",
+    "configure",
+    "init_command",
+    "migrate_command",
+]

shellmate/cli/commands/analyze.py

@@ -0,0 +1,5 @@
+from shellmate.ipc.client import analyze_command as send_to_daemon
+
+
+def analyze_command(command: str, user_queries=None, overrides=None, directives=None) -> dict:
+    return send_to_daemon(command, user_queries=user_queries, overrides=overrides, directives=directives)

shellmate/cli/commands/config.py

@@ -0,0 +1,319 @@
+import os
+import sys
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from shellmate.config import (
+    get_config,
+    set_config_value,
+    CREDENTIAL_KEYS,
+    load_env,
+    save_env,
+    get_credential_status,
+)
+from shellmate.config.credentials import AI_CREDENTIAL_KEYS
+from shellmate.providers.validate_keys import validate_api_key
+
+console = Console()
+
+_PROVIDER_MENU = [
+    ("GROQ_API_KEY", "Groq"),
+    ("OPENROUTER_API_KEY", "OpenRouter"),
+    ("XAI_API_KEY", "Grok (xAI)"),
+    ("CONTEXT7_API_KEY", "Context7 (optional)"),
+]
+
+
+def _is_interactive():
+    if os.environ.get("SM_NONINTERACTIVE"):
+        return False
+    try:
+        return os.isatty(0)
+    except (OSError, AttributeError):
+        return False
+
+
+def config():
+    console.print()
+    console.print(Panel(
+        "[bold]ShellMate Config[/bold]\n"
+        "Set up API keys for AI-powered consequence preview and risk analysis.",
+        border_style="cyan",
+        padding=(0, 2),
+    ))
+    console.print()
+
+    args = [a for a in sys.argv[2:] if a]
+
+    if "--show" in args:
+        _show_config()
+        return
+
+    if args and not args[0].startswith("--"):
+        key = args[0].upper()
+        value = args[1] if len(args) > 1 else ""
+        _config_set(key, value)
+        return
+
+    _display_config_table()
+    if _is_interactive():
+        _interactive_config()
+    else:
+        _validate_existing_keys(report_only=True)
+
+
+def _display_config_table():
+    cfg = get_config()
+    creds = get_credential_status()
+
+    console.print("[bold]ShellMate Configuration[/bold]")
+    console.print()
+
+    table = Table(title="Credentials")
+    table.add_column("Key", style="cyan")
+    table.add_column("Configured", style="green")
+    table.add_column("Value", style="yellow")
+    table.add_column("Description", style="white")
+
+    for key, info in creds.items():
+        meta = CREDENTIAL_KEYS.get(key, {})
+        desc = meta.get("description", "")
+        value_display = info.get("masked", "") if info["configured"] else "[dim]not set[/dim]"
+        table.add_row(key, str(info["configured"]), value_display, desc)
+
+    console.print(table)
+    console.print()
+
+    table2 = Table(title="Providers")
+    table2.add_column("Role", style="cyan")
+    table2.add_column("Primary", style="green")
+    table2.add_column("Model", style="white")
+    table2.add_column("Fallbacks", style="dim")
+
+    providers = cfg.get("providers", {})
+    for role, role_cfg in providers.items():
+        fallbacks = role_cfg.get("fallbacks") or (
+            [role_cfg["fallback"]] if role_cfg.get("fallback") else []
+        )
+        table2.add_row(
+            role,
+            role_cfg.get("primary", ""),
+            role_cfg.get("model", ""),
+            ", ".join(fallbacks) if fallbacks else "none",
+        )
+
+    console.print(table2)
+    console.print()
+
+    console.print("[bold]Settings:[/bold]")
+    for section, values in cfg.items():
+        if section == "providers":
+            continue
+        if isinstance(values, dict):
+            console.print(f"  [cyan]{section}:[/cyan]")
+            for k, v in values.items():
+                console.print(f"    {k}: {v}")
+        else:
+            console.print(f"  {section}: {values}")
+
+    console.print()
+    console.print("[dim]Run 'sm config' interactively to select a provider and paste an API key.[/dim]")
+    console.print("[dim]Use 'sm config provider <role> <primary> [model]' to set provider roles.[/dim]")
+    console.print("[dim]Use 'sm config --show' to view credential values (masked).[/dim]")
+
+
+def _show_config():
+    creds = get_credential_status()
+    console.print("[bold]ShellMate Credentials[/bold]")
+    console.print()
+    for key, info in creds.items():
+        meta = CREDENTIAL_KEYS.get(key, {})
+        label = meta.get("label", key)
+        if info["configured"]:
+            console.print(f"  [cyan]{label}:[/cyan] {info['masked']}")
+        else:
+            console.print(f"  [cyan]{label}:[/cyan] [dim]not set[/dim]")
+    console.print()
+    console.print("[dim]Run 'sm config' for guided setup (select provider, then paste key).[/dim]")
+
+
+def _resolve_key_value(env: dict, key: str) -> str:
+    return (env.get(key) or os.environ.get(key) or "").strip()
+
+
+def _validate_existing_keys(*, report_only: bool = False) -> None:
+    env = load_env()
+    configured = [
+        key for key in CREDENTIAL_KEYS
+        if _resolve_key_value(env, key)
+    ]
+    if not configured:
+        if not report_only:
+            console.print()
+            console.print("[yellow]No API keys configured yet.[/yellow]")
+            console.print(
+                "[dim]Select a provider below and paste a key "
+                "(Groq, OpenRouter, or Grok/xAI).[/dim]"
+            )
+        return
+
+    console.print()
+    console.print("[bold]Checking API keys…[/bold]")
+    for key in configured:
+        meta = CREDENTIAL_KEYS.get(key, {})
+        label = meta.get("label", key)
+        value = _resolve_key_value(env, key)
+        with console.status(f"[cyan]Validating {label}…[/cyan]", spinner="dots"):
+            ok, message = validate_api_key(key, value)
+        if ok:
+            console.print(f"  [green]✔ {label}:[/green] {message}")
+        else:
+            console.print(f"  [red]✖ {label}:[/red] {message}")
+
+
+def _interactive_config():
+    env = load_env()
+    _validate_existing_keys()
+
+    has_ai_key = any(_resolve_key_value(env, k) for k in AI_CREDENTIAL_KEYS)
+    if not has_ai_key:
+        console.print()
+        console.print(
+            "[yellow]At least one of Groq, OpenRouter, or Grok (xAI) is recommended.[/yellow]"
+        )
+
+    changed = False
+    while True:
+        console.print()
+        console.print("[bold]Add or replace an API key[/bold]")
+        for i, (key, name) in enumerate(_PROVIDER_MENU, start=1):
+            current = _resolve_key_value(env, key)
+            status = (
+                f"[green]set ({_mask_key_for_prompt(current)})[/green]"
+                if current
+                else "[dim]not set[/dim]"
+            )
+            console.print(f"  [cyan]{i}.[/cyan] {name}  {status}")
+        console.print("  [cyan]0.[/cyan] Done")
+
+        choice = click.prompt("Select provider", default="0", show_default=True).strip()
+        if choice in ("0", "", "done", "Done", "q", "quit"):
+            break
+
+        try:
+            idx = int(choice)
+        except ValueError:
+            console.print("[red]Invalid selection[/red]")
+            continue
+
+        if idx < 1 or idx > len(_PROVIDER_MENU):
+            console.print("[red]Invalid selection[/red]")
+            continue
+
+        key, name = _PROVIDER_MENU[idx - 1]
+        if _prompt_and_save_key(env, key, name):
+            changed = True
+            env = load_env()
+
+    console.print()
+    if changed:
+        console.print("[green]✔ Credentials saved![/green]")
+        console.print("[dim]Next step:[/dim] run [bold cyan]sm enable[/bold cyan] to start the daemon.")
+    else:
+        console.print("[dim]No changes made[/dim]")
+
+
+def _prompt_and_save_key(env: dict, key: str, name: str) -> bool:
+    meta = CREDENTIAL_KEYS.get(key, {})
+    label = meta.get("label", name)
+    doc_url = meta.get("doc_url", "")
+    description = meta.get("description", "")
+    current = _resolve_key_value(env, key)
+
+    guidance_lines = [f"[bold]{label}[/bold]", f"  {description}"]
+    if doc_url:
+        guidance_lines.append(
+            f"  [dim]Get your key at:[/dim] [cyan underline]{doc_url}[/cyan underline]"
+        )
+    if current:
+        guidance_lines.append(f"  [dim]Current: {_mask_key_for_prompt(current)}[/dim]")
+    console.print()
+    console.print(Panel("\n".join(guidance_lines), border_style="dim", padding=(0, 2)))
+
+    value = click.prompt(
+        f"  Paste {label} (leave empty to cancel)",
+        default="",
+        hide_input=True,
+        show_default=False,
+    ).strip()
+    if not value:
+        console.print("  [dim]Cancelled[/dim]")
+        return False
+
+    with console.status(f"[cyan]Validating {label}…[/cyan]", spinner="dots"):
+        ok, message = validate_api_key(key, value)
+
+    if not ok:
+        console.print(f"  [red]✖ {message}[/red]")
+        if not click.confirm("  Save this key anyway?", default=False):
+            console.print("  [dim]Not saved[/dim]")
+            return False
+        console.print(f"  [yellow]Saved without successful validation[/yellow]")
+    else:
+        console.print(f"  [green]✔ {message}[/green]")
+
+    env[key] = value
+    save_env(env)
+    console.print(f"  [green]✔ {label} saved[/green]")
+    return True
+
+
+def _mask_key_for_prompt(key: str) -> str:
+    if len(key) <= 8:
+        return key[:2] + "*" * (len(key) - 4) + key[-2:] if len(key) > 4 else "****"
+    return key[:2] + "*" * (len(key) - 6) + key[-4:]
+
+
+def _config_set(key: str, value: str):
+    key = key.upper()
+    if key in CREDENTIAL_KEYS:
+        env = load_env()
+        env[key] = value
+        save_env(env)
+        console.print(f"[green]Updated {key}[/green]")
+        return
+
+    if key.lower() == "provider" and len(sys.argv) >= 5:
+        role = sys.argv[3].lower()
+        primary = sys.argv[4]
+        model = sys.argv[5] if len(sys.argv) > 5 else ""
+        _set_provider(role, primary, model)
+        return
+
+    if "." in key:
+        set_config_value(key, value)
+        console.print(f"[green]Set {key} = {value}[/green]")
+        return
+
+    console.print(f"[red]Unknown config key: {key}[/red]")
+    console.print(f"Credential keys: {', '.join(CREDENTIAL_KEYS.keys())}")
+    console.print("Or use dotted notation: sm config cache.similarity_threshold 0.95")
+
+
+def _set_provider(role: str, primary: str, model: str):
+    cfg = get_config()
+    if "providers" not in cfg:
+        cfg["providers"] = {}
+
+    if role not in cfg["providers"]:
+        cfg["providers"][role] = {}
+
+    cfg["providers"][role]["primary"] = primary
+    if model:
+        cfg["providers"][role]["model"] = model
+
+    from shellmate.config.manager import get_config_manager
+    get_config_manager().save(cfg)
+    console.print(f"[green]Updated provider {role}: {primary} ({model})[/green]")