shellmate-cli 3.0.0__py3-none-any.whl

shellmate/cli/commands/install.py

@@ -0,0 +1,242 @@
+import os
+import shutil
+from importlib.resources import as_file, files as _pkg_files
+from pathlib import Path
+
+import click
+from shellmate.environment.detector import detect_environment
+
+
+def _get_adapter_src(filename: str) -> Path:
+    """Return path to a bundled adapter file inside the installed package."""
+    ref = _pkg_files("shellmate").joinpath(f"adapters/{filename}")
+    # importlib.resources may return a non-Path on older Python — make it concrete
+    with as_file(ref) as p:
+        return Path(p)
+
+
+def _get_shellmate_dir() -> Path:
+    """~/.shellmate on Unix, %USERPROFILE%\\.shellmate on Windows."""
+    return Path.home() / ".shellmate"
+
+
+def _install_adapter(filename: str) -> Path:
+    """Copy adapter from package to ~/.shellmate/adapters/ and return dest path."""
+    dest_dir = _get_shellmate_dir() / "adapters"
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    src = _get_adapter_src(filename)
+    dest = dest_dir / filename
+    shutil.copy2(src, dest)
+    dest.chmod(0o755)
+    return dest
+
+
+def _adapter_filename_for_shell(shell: str):
+    """Unix shells use ble_adapter.sh; Windows uses powershell_adapter.ps1."""
+    if shell == "powershell":
+        return "powershell_adapter.ps1"
+    if shell in ("bash", "zsh"):
+        return "ble_adapter.sh"
+    return None
+
+
+def _get_rc_file(shell):
+    home = os.path.expanduser("~")
+    rc_map = {
+        "bash": [os.path.join(home, ".bashrc"), os.path.join(home, ".bash_profile")],
+        "zsh": [os.path.join(home, ".zshrc")],
+        "powershell": [
+            os.path.join(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1"),
+            os.path.join(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1"),
+        ],
+    }
+    return rc_map.get(shell, [])
+
+
+def _source_line(shell: str, filename: str) -> str:
+    if shell == "powershell":
+        return '. "$env:USERPROFILE\\.shellmate\\adapters\\powershell_adapter.ps1"\n'
+    return f'source "$HOME/.shellmate/adapters/{filename}"\n'
+
+
+def _install_hook(shell):
+    adapter_name = _adapter_filename_for_shell(shell)
+    if not adapter_name:
+        return False, f"No adapter available for {shell}"
+
+    try:
+        dest_path = _install_adapter(adapter_name)
+    except (FileNotFoundError, OSError) as e:
+        return False, f"Adapter file not found: {e}"
+
+    rc_files = _get_rc_file(shell)
+    if not rc_files:
+        return False, f"No RC file known for {shell}"
+
+    source_line = _source_line(shell, adapter_name)
+
+    installed = False
+    for rc_file in rc_files:
+        if os.path.exists(rc_file):
+            with open(rc_file, "r") as f:
+                content = f.read()
+            if source_line.strip() in content:
+                installed = True  # already present — idempotent success
+                continue
+            with open(rc_file, "a") as f:
+                f.write(f"\n# ShellMate hook\n{source_line}")
+            installed = True
+        else:
+            rc_dir = os.path.dirname(rc_file)
+            if rc_dir and not os.path.exists(rc_dir):
+                os.makedirs(rc_dir, exist_ok=True)
+            try:
+                with open(rc_file, "w") as f:
+                    f.write(f"# ShellMate hook\n{source_line}")
+                installed = True
+            except OSError:
+                pass
+
+    if installed:
+        return True, f"Hook installed for {shell} → {dest_path}"
+    return False, f"Could not install hook for {shell}"
+
+
+def _dry_run_adapter_plan(shell):
+    """Describe the copy that install would perform (for --dry-run)."""
+    adapter_name = _adapter_filename_for_shell(shell)
+    if not adapter_name:
+        return False, f"No adapter available for {shell}"
+    try:
+        src = _get_adapter_src(adapter_name)
+    except (FileNotFoundError, OSError, ModuleNotFoundError) as e:
+        return False, f"Adapter file not found: {e}"
+    dest = _get_shellmate_dir() / "adapters" / adapter_name
+    return True, f"Would copy {src} → {dest}"
+
+
+def _prompt_credential_setup():
+    click.echo()
+    click.echo(click.style("  -------------------------------------------------", fg="cyan"))
+    click.echo(click.style("  ShellMate Credential Setup", bold=True, fg="cyan"))
+    click.echo(click.style("  -------------------------------------------------", fg="cyan"))
+    click.echo()
+    click.echo("  ShellMate needs API keys for AI-powered analysis and remediation.")
+    click.echo("  You can set them up now or skip and configure later with:")
+    click.echo("    " + click.style("shellmate configure", bold=True))
+    click.echo()
+
+    if not click.confirm(click.style("  Would you like to configure API keys now?", bold=True), default=True):
+        click.echo()
+        click.echo("  You can always run " + click.style("shellmate configure", bold=True) + " later.")
+        click.echo("  Until then, ShellMate will use deterministic rule-based analysis.")
+        return
+
+    from shellmate.cli.commands.configure import print_header, print_status, prompt_for_key
+    from shellmate.config.credentials import CREDENTIAL_KEYS, load_env, save_env
+
+    env = load_env()
+    print_header()
+    print_status()
+
+    click.echo()
+    for key_name in CREDENTIAL_KEYS:
+        current = env.get(key_name, os.environ.get(key_name, ""))
+        new_value = prompt_for_key(key_name, current)
+        env[key_name] = new_value
+
+    save_env(env)
+
+    click.echo()
+    click.echo(click.style("  [OK] Credentials saved to ~/.shellmate/.env", fg="green"))
+    click.echo()
+    click.echo("  " + click.style("Next step:", bold=True))
+    click.echo("  Run " + click.style("shellmate enable", bold=True) + " to start the daemon.")
+    click.echo()
+
+
+@click.command()
+@click.option("--dry-run", is_flag=True, help="Show what would be installed without making changes")
+def install(dry_run):
+    """Install ShellMate shell hooks"""
+    from rich.console import Console
+    from rich.progress import Progress, SpinnerColumn, TextColumn
+    from rich.panel import Panel
+    import time
+    from shellmate.ui.runtime import tokens
+
+    console = Console()
+    env = detect_environment()
+    shell = env["shell"]
+    os_name = env["os"]
+    # Windows consoles often lack UTF-8; use ASCII marks (same pattern as daemon/server)
+    icon = tokens.icons(ascii_safe=(os.name == "nt" or console.no_color))
+    done = icon["done"]
+    fail = icon["error"]
+
+    console.print()
+    console.print(Panel(
+        f"[bold]ShellMate Install[/bold]\nSetting up hooks for [cyan]{os_name}[/cyan] / [cyan]{shell}[/cyan]",
+        border_style="cyan",
+        padding=(0, 2),
+    ))
+    console.print()
+
+    steps = [
+        ("Detecting shell environment", lambda: (True, f"Detected {shell} on {os_name}")),
+        ("Locating adapter file", lambda: (
+            (
+                True,
+                f"Adapter: {_adapter_filename_for_shell(shell)}"
+            ) if _adapter_filename_for_shell(shell) else (False, "not found")
+        )),
+        ("Installing hook", lambda: (
+            _dry_run_adapter_plan(shell) if dry_run else _install_hook(shell)
+        )),
+        ("Verifying shell config", lambda: (
+            True,
+            (
+                f'[DRY RUN] Would write: {_source_line(shell, _adapter_filename_for_shell(shell) or "").strip()}'
+                if dry_run
+                else "Source line written"
+            )
+        )),
+    ]
+
+    all_ok = True
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+        transient=False,
+    ) as progress:
+        for label, action in steps:
+            task = progress.add_task(f"[cyan]{label}...[/cyan]", total=None)
+            time.sleep(0.05)  # let spinner render at least one frame
+            try:
+                result = action()
+                ok = result[0] if isinstance(result, tuple) else bool(result)
+                detail = result[1] if isinstance(result, tuple) and len(result) > 1 else ""
+                if ok:
+                    progress.update(task, description=f"[green]{done} {label}[/green]  [dim]{detail}[/dim]", completed=1, total=1)
+                else:
+                    progress.update(task, description=f"[red]{fail} {label}[/red]  [dim]{detail}[/dim]", completed=1, total=1)
+                    all_ok = False
+            except Exception as e:
+                progress.update(task, description=f"[red]{fail} {label}: {e}[/red]", completed=1, total=1)
+                all_ok = False
+
+    console.print()
+    if all_ok and not dry_run:
+        console.print("[green]Shell hooks installed.[/green] Restart your shell or run:")
+        if shell == "powershell":
+            console.print("  [bold]. $PROFILE[/bold]")
+        else:
+            console.print(f"  [bold]source ~/{'.bashrc' if shell == 'bash' else '.zshrc'}[/bold]")
+        console.print()
+        console.print("[dim]Next step:[/dim] run [bold cyan]sm config[/bold cyan] to set up API keys")
+        _prompt_credential_setup()
+    elif dry_run:
+        console.print("[dim]Dry run complete -- no changes made.[/dim]")
+    else:
+        console.print("[red]Install incomplete -- check output above.[/red]")

shellmate/cli/commands/migrate.py

@@ -0,0 +1,147 @@
+"""Migrate from deprecated interception hooks to autocomplete mode."""
+
+import os
+
+import click
+
+from shellmate.cli.commands.init import (
+    _check_blesh_installed,
+    _confirm,
+    _echo,
+    _install_autocomplete_hook,
+    _install_blesh,
+    _install_powershell_hook,
+    _is_windows_target,
+    _powershell_profile_paths,
+    _profile_integration_ok,
+)
+
+
+@click.command(name="migrate-to-autocomplete")
+def migrate():
+    """Migrate from deprecated interception mode to autocomplete mode"""
+
+    _echo("\nShellMate Migration Tool\n", bold=True, fg="cyan")
+    _echo("Interception mode (preexec hooks) has been removed.")
+    _echo("This migration sets up autocomplete mode for your shell.\n")
+
+    windows = _is_windows_target()
+    home = os.path.expanduser("~")
+    bashrc = os.path.join(home, ".bashrc")
+
+    has_old_bash = _has_legacy_bash_hooks(bashrc)
+    has_old_ps = _has_legacy_powershell_hooks()
+
+    if not has_old_bash and not has_old_ps:
+        _echo("[OK] No interception mode hooks found.")
+        if _profile_integration_ok():
+            _echo("[OK] Autocomplete mode already configured!")
+            return
+        _echo("[!] Autocomplete mode not configured. Run: sm init")
+        return
+
+    if has_old_bash:
+        _echo("Found old interception mode hooks in .bashrc")
+    if has_old_ps:
+        _echo("Found old ShellMate hooks in a PowerShell profile")
+
+    if not _confirm("Continue with migration?", default=True):
+        return
+
+    if windows:
+        if has_old_ps:
+            _echo("\nRemoving old PowerShell hooks...")
+            for path in _powershell_profile_paths():
+                if os.path.exists(path):
+                    _remove_legacy_marker_sections(path, markers=("# ShellMate hook",))
+        _echo("Installing PowerShell autocomplete hooks...")
+        _install_powershell_hook()
+    else:
+        if not _check_blesh_installed():
+            _echo("\nble.sh is required for autocomplete mode.")
+            if _confirm("Install ble.sh now?", default=True):
+                if not _install_blesh():
+                    _echo("Migration aborted.")
+                    return
+            else:
+                _echo("Migration aborted.")
+                return
+
+        if has_old_bash:
+            _echo("\nRemoving old interception mode hooks from .bashrc...")
+            _remove_old_hooks(bashrc)
+
+        _echo("Installing autocomplete hooks...")
+        _install_autocomplete_hook()
+
+    _echo("\n[OK] Migration complete!", bold=True, fg="green")
+    _echo("\nWhat changed:")
+    _echo("  - Removed preexec-based interception hooks (if present)")
+    if windows:
+        _echo("  - Installed PowerShell adapter for real-time annotations")
+    else:
+        _echo("  - Installed ble.sh autocomplete integration")
+    _echo("  - Preserved FAISS semantic cache for fast lookups")
+    _echo("\nNext steps:")
+    if windows:
+        _echo("  1. Restart PowerShell (or reload your profile)")
+    else:
+        _echo("  1. Restart your shell (or run: source ~/.bashrc)")
+    _echo("  2. Run: sm enable")
+    _echo("  3. Start typing commands to see autocomplete!\n")
+
+
+def _has_legacy_bash_hooks(bashrc_path: str) -> bool:
+    if not os.path.exists(bashrc_path):
+        return False
+    with open(bashrc_path, "r", encoding="utf-8", errors="replace") as f:
+        content = f.read()
+    return "bash_adapter.sh" in content and (
+        "preexec" in content or "# ShellMate hook" in content
+    )
+
+
+def _has_legacy_powershell_hooks() -> bool:
+    for path in _powershell_profile_paths():
+        if not os.path.exists(path):
+            continue
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+        # Legacy install.py wrote "# ShellMate hook" without autocomplete marker
+        if "# ShellMate hook" in content and "ShellMate Autocomplete" not in content:
+            return True
+        if "powershell_adapter.ps1" in content and "ShellMate Autocomplete" not in content:
+            return True
+    return False
+
+
+def _remove_legacy_marker_sections(path: str, markers=("# ShellMate hook",)):
+    """Remove simple one/two-line hook blocks starting with markers."""
+    with open(path, "r", encoding="utf-8", errors="replace") as f:
+        lines = f.readlines()
+
+    new_lines = []
+    skip_section = False
+    for line in lines:
+        if any(marker in line for marker in markers):
+            skip_section = True
+            continue
+        if skip_section:
+            stripped = line.strip()
+            if not stripped:
+                skip_section = False
+                continue
+            if stripped.startswith("source") or stripped.startswith("."):
+                skip_section = False
+                continue
+            skip_section = False
+        new_lines.append(line)
+
+    with open(path, "w", encoding="utf-8") as f:
+        f.writelines(new_lines)
+    _echo(f"[OK] Cleaned hooks in {path}")
+
+
+def _remove_old_hooks(bashrc_path):
+    """Remove old ShellMate preexec hooks from .bashrc"""
+    _remove_legacy_marker_sections(bashrc_path, markers=("# ShellMate hook",))

shellmate/cli/commands/status.py

@@ -0,0 +1,31 @@
+from shellmate.ui.scenes.status import render_status
+
+from shellmate.daemon.lifecycle import check_daemon_status
+from shellmate.providers.router import get_provider_status
+from shellmate.config.credentials import get_credential_status
+from shellmate.config.defaults import get_default_config
+from shellmate.ui.runtime.console_factory import ConsoleFactory
+
+
+def status():
+    daemon_status = check_daemon_status()
+    provider_status = get_provider_status()
+    credential_status = get_credential_status()
+    config = get_default_config()
+
+    agent_status = None
+    if daemon_status.get("status") == "running":
+        # Optional: agents may be absent from lifecycle status
+        agent_status = daemon_status.get("agents")
+
+    factory = ConsoleFactory()
+    console = factory.create()
+    render_status(
+        daemon_status,
+        provider_status,
+        credential_status,
+        agent_status=agent_status,
+        config=config,
+        console=console,
+        plain=factory.is_plain(),
+    )

shellmate/cli/commands/uninstall.py

@@ -0,0 +1,78 @@
+import os
+import click
+from shellmate.environment.detector import detect_environment
+
+SHELLMATE_DIR = os.path.expanduser("~/.shellmate")
+HOOKS_DIR = os.path.join(SHELLMATE_DIR, "hooks")
+
+
+def _get_rc_file(shell):
+    home = os.path.expanduser("~")
+    rc_map = {
+        "bash": [os.path.join(home, ".bashrc"), os.path.join(home, ".bash_profile")],
+        "zsh": [os.path.join(home, ".zshrc")],
+        "powershell": [
+            os.path.join(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1"),
+            os.path.join(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1"),
+        ],
+    }
+    return rc_map.get(shell, [])
+
+
+def _remove_hook(shell):
+    rc_files = _get_rc_file(shell)
+    removed = False
+
+    for rc_file in rc_files:
+        if not os.path.exists(rc_file):
+            continue
+        try:
+            with open(rc_file, "r") as f:
+                lines = f.readlines()
+
+            new_lines = []
+            skip_next = False
+            for line in lines:
+                if "# ShellMate hook" in line:
+                    skip_next = True
+                    removed = True
+                    continue
+                if skip_next:
+                    skip_next = False
+                    removed = True
+                    continue
+                if "shellmate" in line.lower() and ("source" in line or ". " in line):
+                    if HOOKS_DIR in line:
+                        removed = True
+                        continue
+                new_lines.append(line)
+
+            with open(rc_file, "w") as f:
+                f.writelines(new_lines)
+        except OSError:
+            pass
+
+    return removed
+
+
+@click.command()
+@click.option("--dry-run", is_flag=True, help="Show what would be removed without making changes")
+def uninstall(dry_run):
+    """Remove ShellMate and all hooks"""
+    env = detect_environment()
+    shell = env["shell"]
+
+    if dry_run:
+        rc_files = _get_rc_file(shell)
+        click.echo(f"[DRY RUN] Would remove ShellMate hooks for {shell}")
+        for rc in rc_files:
+            click.echo(f"[DRY RUN] Would remove hooks from: {rc}")
+        return
+
+    removed = _remove_hook(shell)
+    if removed:
+        click.echo("Shell hooks removed from RC files.")
+    else:
+        click.echo("No ShellMate hooks found in RC files.")
+
+    click.echo("ShellMate uninstalled.")

shellmate/cli/main.py

@@ -0,0 +1,114 @@
+import sys
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from shellmate.cli.parser import parse_argv, ParsedCommand, Action, ExitCode
+from shellmate.cli.commands.enable import enable
+from shellmate.cli.commands.disable import disable
+from shellmate.cli.commands.status import status
+from shellmate.cli.commands.config import config
+from shellmate.cli.version import VERSION
+
+console = Console()
+
+_plain_console = Console(no_color=True)
+
+
+def _get_console(parsed=None):
+    if parsed and getattr(parsed, 'no_color', False):
+        return _plain_console
+    return console
+
+
+def print_error_panel(error: str, suggestion: str = None, next_steps: list = None, _console=None):
+    c = _console or console
+    text = Text()
+    text.append("Error: ", style="bold red")
+    text.append(error, style="red")
+    if suggestion:
+        text.append("\n\n")
+        text.append("Suggestion: ", style="bold yellow")
+        text.append(suggestion, style="yellow")
+    if next_steps:
+        text.append("\n\n")
+        text.append("Next steps:", style="bold cyan")
+        for i, step in enumerate(next_steps, 1):
+            text.append(f"\n  {i}. {step}", style="cyan")
+    c.print(Panel(text, border_style="red", title="[bold red]ShellMate Error[/bold red]"))
+
+
+def print_usage(c: Console = None):
+    from shellmate.ui.scenes.help import print_help
+    print_help(c or console)
+
+
+def _safe_echo(message: str):
+    """click.echo that survives Windows consoles rejecting emoji/codepoints."""
+    try:
+        click.echo(message)
+    except UnicodeEncodeError:
+        click.echo(message.encode("ascii", errors="replace").decode("ascii"))
+
+
+def main():
+    parsed = parse_argv(sys.argv[1:])
+    c = _get_console(parsed)
+
+    if parsed.exit_code != ExitCode.SUCCESS:
+        print_error_panel(parsed.error, parsed.suggestion, _console=c)
+        sys.exit(parsed.exit_code.value)
+
+    try:
+        if parsed.action == Action.ENABLE:
+            enable()
+            sys.exit(ExitCode.SUCCESS.value)
+
+        elif parsed.action == Action.DISABLE:
+            disable()
+            sys.exit(ExitCode.SUCCESS.value)
+
+        elif parsed.action == Action.STATUS:
+            status()
+            sys.exit(ExitCode.SUCCESS.value)
+
+        elif parsed.action == Action.CONFIG:
+            config()
+            sys.exit(ExitCode.SUCCESS.value)
+
+        elif parsed.action == Action.INSTALL:
+            from shellmate.cli.commands.install import install
+            # Click Command: invoke underlying callback, not Command.__call__
+            # Accept --dry-run before or after the subcommand
+            dry_run = parsed.dry_run or ("--dry-run" in (getattr(parsed, "tokens", None) or []))
+            install.callback(dry_run=dry_run)
+            sys.exit(ExitCode.SUCCESS.value)
+
+        elif parsed.action == Action.UNINSTALL:
+            from shellmate.cli.commands.uninstall import uninstall
+            dry_run = parsed.dry_run or ("--dry-run" in (getattr(parsed, "tokens", None) or []))
+            uninstall.callback(dry_run=dry_run)
+            sys.exit(ExitCode.SUCCESS.value)
+
+        elif parsed.action == Action.HELP:
+            print_usage(c)
+            sys.exit(ExitCode.SUCCESS.value)
+
+        elif parsed.action == Action.VERSION:
+            c.print(f"ShellMate v{VERSION}")
+            sys.exit(ExitCode.SUCCESS.value)
+
+    except KeyboardInterrupt:
+        c.print("\n[yellow]Interrupted[/]")
+        sys.exit(ExitCode.TEMP_ERROR.value)
+    except click.Abort:
+        c.print("\n[yellow]Aborted[/]")
+        sys.exit(ExitCode.TEMP_ERROR.value)
+    except Exception as e:
+        print_error_panel(f"Internal error: {e}", "Run 'sm --help' or check logs", _console=c)
+        sys.exit(ExitCode.INTERNAL_ERROR.value)
+
+
+if __name__ == "__main__":
+    main()