natshell 0.1.0__py3-none-any.whl

natshell/__main__.py

@@ -0,0 +1,320 @@
+"""NatShell entry point — CLI argument parsing, model setup, and app launch."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+import subprocess
+import sys
+from pathlib import Path
+
+from natshell.config import load_config
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="natshell",
+        description="NatShell — Natural language shell interface for Linux",
+    )
+    parser.add_argument(
+        "--config", "-c",
+        help="Path to config.toml file",
+    )
+    parser.add_argument(
+        "--model", "-m",
+        help="Path to a GGUF model file (overrides config)",
+    )
+    parser.add_argument(
+        "--remote",
+        help="URL of an OpenAI-compatible API to use instead of local model "
+             "(e.g., http://localhost:11434/v1)",
+    )
+    parser.add_argument(
+        "--remote-model",
+        help="Model name for the remote API (e.g., qwen3:4b)",
+    )
+    parser.add_argument(
+        "--local",
+        action="store_true",
+        help="Force local model (ignore remote/Ollama configuration)",
+    )
+    parser.add_argument(
+        "--download",
+        action="store_true",
+        help="Download the default model and exit",
+    )
+    parser.add_argument(
+        "--update",
+        action="store_true",
+        help="Pull latest code and reinstall (git installs only)",
+    )
+    parser.add_argument(
+        "--verbose", "-v",
+        action="store_true",
+        help="Enable verbose logging",
+    )
+    parser.add_argument(
+        "--danger-fast",
+        action="store_true",
+        help="Skip all confirmation dialogs. BLOCKED commands are still blocked. "
+             "Only use this on VMs or test environments.",
+    )
+
+    args = parser.parse_args()
+
+    # Setup logging
+    level = logging.DEBUG if args.verbose else logging.WARNING
+    logging.basicConfig(level=level, format="%(name)s: %(message)s")
+
+    # Handle self-update
+    if args.update:
+        _self_update()
+        return
+
+    # Load config
+    config = load_config(args.config)
+
+    # Conflict check
+    if args.local and args.remote:
+        print("Error: --local and --remote cannot be used together.")
+        sys.exit(1)
+
+    # Override config with CLI args
+    if args.model:
+        config.model.path = args.model
+    if args.remote:
+        config.remote.url = args.remote
+    if args.remote_model:
+        config.remote.model = args.remote_model
+
+    # Handle model download
+    if args.download or config.model.path == "auto":
+        model_path = _ensure_model(config)
+        if args.download:
+            print(f"Model ready at: {model_path}")
+            return
+        config.model.path = model_path
+
+    # Determine remote URL and model (CLI --remote > [remote] > [ollama])
+    remote_url = config.remote.url
+    remote_model = config.remote.model
+    remote_api_key = config.remote.api_key
+    use_remote = bool(remote_url)
+    fallback_config = None
+
+    # Ensure remote URL has a scheme
+    if remote_url and not remote_url.startswith(("http://", "https://")):
+        remote_url = f"http://{remote_url}"
+
+    if not remote_url and config.ollama.url:
+        from natshell.inference.ollama import normalize_base_url
+        base = normalize_base_url(config.ollama.url)
+        remote_url = f"{base}/v1"
+        remote_model = remote_model or config.ollama.default_model or "qwen3:4b"
+        use_remote = True
+
+    if not remote_model:
+        remote_model = "qwen3:4b"
+
+    # Apply --local override before preference logic
+    if args.local:
+        use_remote = False
+
+    # Apply persisted engine preference (CLI flags override)
+    cli_forced_remote = bool(args.remote)
+    cli_forced_local = bool(args.model) or args.local
+    if not cli_forced_remote and not cli_forced_local:
+        if config.engine.preferred == "local":
+            use_remote = False
+        elif config.engine.preferred == "remote":
+            pass  # keep use_remote as-is (try remote if URL exists)
+
+    # Build the inference engine
+    if use_remote:
+        from natshell.inference.ollama import ping_server
+
+        print(f"Checking remote server: {remote_url}...")
+        reachable = asyncio.run(ping_server(remote_url))
+
+        if reachable:
+            from natshell.inference.ollama import get_model_context_length
+            from natshell.inference.remote import RemoteEngine
+            n_ctx = asyncio.run(get_model_context_length(remote_url, remote_model))
+            engine = RemoteEngine(
+                base_url=remote_url,
+                model=remote_model,
+                api_key=remote_api_key,
+                n_ctx=n_ctx,
+            )
+            fallback_config = config.model
+            print(f"Using remote model: {remote_model} at {remote_url}")
+        else:
+            print(f"Remote server unreachable at {remote_url}. Falling back to local model.")
+            use_remote = False
+
+    if not use_remote:
+        from natshell.inference.local import LocalEngine
+        print(f"Loading model: {config.model.path}...")
+        engine = LocalEngine(
+            model_path=config.model.path,
+            n_ctx=config.model.n_ctx,
+            n_threads=config.model.n_threads,
+            n_gpu_layers=config.model.n_gpu_layers,
+            main_gpu=config.model.main_gpu,
+        )
+        try:
+            from llama_cpp import llama_supports_gpu_offload
+            if config.model.n_gpu_layers != 0 and not llama_supports_gpu_offload():
+                from natshell.gpu import detect_gpus
+                from natshell.platform import is_macos
+
+                gpus = detect_gpus()
+                if is_macos():
+                    gpu_flag = "-DGGML_METAL=on"
+                else:
+                    gpu_flag = "-DGGML_VULKAN=on"
+
+                print("WARNING: GPU offloading requested but llama-cpp-python was built without GPU support.")
+                if gpus:
+                    gpu = gpus[0]
+                    vram = f" ({gpu.vram_mb} MB VRAM)" if gpu.vram_mb else ""
+                    print(f"  Detected GPU: {gpu.name}{vram}")
+
+                print(f'  Reinstall with: CMAKE_ARGS="{gpu_flag}" pip install llama-cpp-python --no-binary llama-cpp-python --force-reinstall')
+
+                if not is_macos():
+                    _print_vulkan_dep_hint()
+        except ImportError:
+            pass
+        print("Model loaded.")
+
+    # Build the tool registry
+    from natshell.tools.registry import create_default_registry
+    tools = create_default_registry()
+
+    # Build the safety classifier
+    from natshell.safety.classifier import SafetyClassifier
+    safety = SafetyClassifier(config.safety)
+
+    # Inject safety config into the natshell_help tool
+    from natshell.tools.natshell_help import set_safety_config
+    set_safety_config(config.safety)
+
+    # Build the agent
+    from natshell.agent.loop import AgentLoop
+    agent = AgentLoop(
+        engine=engine,
+        tools=tools,
+        safety=safety,
+        config=config.agent,
+        fallback_config=fallback_config,
+    )
+
+    # Gather system context and initialize agent
+    from natshell.agent.context import gather_system_context
+    print("Gathering system information...")
+    context = asyncio.run(gather_system_context())
+    agent.initialize(context)
+
+    # Launch the TUI
+    from natshell.app import NatShellApp
+    if args.danger_fast:
+        print("WARNING: --danger-fast is active. All confirmations will be skipped.")
+    app = NatShellApp(agent=agent, config=config, skip_permissions=args.danger_fast)
+    app.run()
+
+
+def _print_vulkan_dep_hint() -> None:
+    """Print distro-specific instructions for installing Vulkan build deps."""
+    import shutil
+    from pathlib import Path
+
+    if shutil.which("rpm-ostree") and Path("/run/ostree-booted").exists():
+        print("  Install Vulkan build deps: sudo rpm-ostree install vulkan-devel glslc")
+        print("  Then reboot and re-run install.sh")
+    elif shutil.which("dnf"):
+        print("  Install Vulkan build deps: sudo dnf install vulkan-devel glslc")
+    elif shutil.which("apt-get"):
+        print("  Install Vulkan build deps: sudo apt install libvulkan-dev glslang-tools")
+    elif shutil.which("pacman"):
+        print("  Install Vulkan build deps: sudo pacman -S vulkan-headers glslang")
+    else:
+        print("  Ensure Vulkan development headers and a GLSL shader compiler are installed.")
+
+
+def _self_update() -> None:
+    """Pull latest code and reinstall from the git checkout."""
+    # Navigate from src/natshell/__main__.py -> project root
+    root = Path(__file__).resolve().parent.parent.parent
+    if not (root / ".git").exists():
+        print("Not a git install. Re-run install.sh to update.")
+        sys.exit(1)
+
+    print(f"Updating NatShell from {root}...")
+    result = subprocess.run(
+        ["git", "-C", str(root), "pull", "--ff-only"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        print(f"git pull failed:\n{result.stderr.strip()}")
+        sys.exit(1)
+    print(result.stdout.strip())
+
+    # Reinstall using the same Python that's running us
+    pip = str(Path(sys.executable).parent / "pip")
+    result = subprocess.run(
+        [pip, "install", "-e", str(root), "-q"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        print(f"pip install failed:\n{result.stderr.strip()}")
+        sys.exit(1)
+
+    print("Update complete.")
+
+
+def _ensure_model(config) -> str:
+    """Ensure the default model is downloaded. Returns the model path."""
+    model_dir = Path.home() / ".local" / "share" / "natshell" / "models"
+    model_dir.mkdir(parents=True, exist_ok=True)
+
+    target = model_dir / config.model.hf_file
+    if target.exists():
+        return str(target)
+
+    # Prompt user
+    print(f"\nNo local model found.")
+    print(f"Download {config.model.hf_file} from {config.model.hf_repo}?")
+    print(f"This is approximately 2.5 GB.\n")
+
+    response = input("Download now? [Y/n]: ").strip().lower()
+    if response and response != "y":
+        print("No model available. Use --model or --remote to specify one.")
+        sys.exit(1)
+
+    try:
+        from huggingface_hub import hf_hub_download
+
+        print(f"Downloading from HuggingFace...")
+        path = hf_hub_download(
+            repo_id=config.model.hf_repo,
+            filename=config.model.hf_file,
+            local_dir=str(model_dir),
+        )
+        print(f"Model saved to: {path}")
+        return path
+
+    except ImportError:
+        print("huggingface-hub is required for model download.")
+        print("Install it: pip install huggingface-hub")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Download failed: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

natshell/agent/context.py

@@ -0,0 +1,320 @@
+"""Gather system context for injection into the LLM system prompt."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import subprocess
+from dataclasses import dataclass, field
+
+from natshell.platform import is_macos
+
+
+@dataclass
+class DiskInfo:
+    mount: str
+    total: str
+    used: str
+    available: str
+    use_percent: str
+
+
+@dataclass
+class NetInfo:
+    name: str
+    ip: str
+    subnet: str
+
+
+@dataclass
+class SystemContext:
+    hostname: str = ""
+    distro: str = ""
+    kernel: str = ""
+    arch: str = ""
+    cpu: str = ""
+    ram_total_gb: float = 0.0
+    ram_available_gb: float = 0.0
+    username: str = ""
+    is_root: bool = False
+    has_sudo: bool = False
+    shell: str = ""
+    package_manager: str = ""
+    cwd: str = ""
+    disks: list[DiskInfo] = field(default_factory=list)
+    network: list[NetInfo] = field(default_factory=list)
+    default_gateway: str = ""
+    installed_tools: dict[str, bool] = field(default_factory=dict)
+    running_services: list[str] = field(default_factory=list)
+    containers: list[str] = field(default_factory=list)
+
+    def to_prompt_text(self) -> str:
+        """Format system context as a compact text block for the system prompt."""
+        lines = []
+
+        # Host info
+        lines.append(
+            f"Host: {self.hostname} | {self.distro} | {self.kernel} | {self.arch}"
+        )
+        lines.append(
+            f"CPU: {self.cpu} | RAM: {self.ram_total_gb:.1f}GB total, "
+            f"{self.ram_available_gb:.1f}GB available"
+        )
+        sudo_str = "yes" if self.has_sudo else "no"
+        lines.append(
+            f"User: {self.username} (sudo: {sudo_str}) | Shell: {self.shell} | "
+            f"Pkg: {self.package_manager}"
+        )
+        lines.append(f"CWD: {self.cwd}")
+
+        # Disks
+        if self.disks:
+            disk_parts = [f"{d.mount} {d.total} ({d.use_percent} used)" for d in self.disks]
+            lines.append(f"Disks: {', '.join(disk_parts)}")
+
+        # Network
+        if self.network:
+            net_parts = [f"{n.name} {n.ip}/{n.subnet}" for n in self.network]
+            lines.append(f"Network: {' | '.join(net_parts)}")
+        if self.default_gateway:
+            lines.append(f"Gateway: {self.default_gateway}")
+
+        # Tools
+        if self.installed_tools:
+            present = [k + "✓" for k, v in self.installed_tools.items() if v]
+            missing = [k + "✗" for k, v in self.installed_tools.items() if not v]
+            lines.append(f"Tools: {' '.join(present + missing)}")
+
+        # Containers
+        if self.containers:
+            lines.append(f"Containers: {', '.join(self.containers[:10])}")
+
+        # Services
+        if self.running_services:
+            lines.append(f"Services: {', '.join(self.running_services[:15])}")
+
+        return "\n".join(lines)
+
+
+async def _run(cmd: str) -> str:
+    """Run a shell command and return stripped stdout, or empty string on failure."""
+    try:
+        result = await asyncio.to_thread(
+            subprocess.run,
+            ["bash", "-c", cmd],
+            capture_output=True, text=True, timeout=5,
+        )
+        return result.stdout.strip()
+    except Exception:
+        return ""
+
+
+def _parse_linux_df(df_output: str) -> list[DiskInfo]:
+    """Parse Linux ``df -h --output=...`` output into DiskInfo entries."""
+    disks = []
+    for line in df_output.splitlines():
+        parts = line.split()
+        if len(parts) >= 5:
+            disks.append(DiskInfo(
+                mount=parts[0], total=parts[1], used=parts[2],
+                available=parts[3], use_percent=parts[4],
+            ))
+    return disks
+
+
+def _parse_macos_df(df_output: str) -> list[DiskInfo]:
+    """Parse macOS ``df -h`` output (no ``--output`` flag) into DiskInfo entries."""
+    disks = []
+    for line in df_output.splitlines():
+        parts = line.split()
+        # macOS df -h: Filesystem Size Used Avail Capacity ... Mounted on
+        if len(parts) >= 9 and parts[4].endswith("%"):
+            mount = " ".join(parts[8:])  # Mounted on may contain spaces
+            disks.append(DiskInfo(
+                mount=mount, total=parts[1], used=parts[2],
+                available=parts[3], use_percent=parts[4],
+            ))
+    return disks
+
+
+def _parse_linux_ip(ip_output: str) -> list[NetInfo]:
+    """Parse Linux ``ip -4 -o addr show`` output into NetInfo entries."""
+    interfaces = []
+    for line in ip_output.splitlines():
+        parts = line.split()
+        if len(parts) >= 2 and "/" in parts[1]:
+            ip, prefix = parts[1].split("/")
+            if not ip.startswith("127."):
+                interfaces.append(NetInfo(name=parts[0], ip=ip, subnet=prefix))
+    return interfaces
+
+
+def _parse_macos_ifconfig(ifconfig_output: str) -> list[NetInfo]:
+    """Parse macOS ``ifconfig | grep 'inet '`` output into NetInfo entries."""
+    interfaces = []
+    for line in ifconfig_output.splitlines():
+        line = line.strip()
+        # Format: "inet 192.168.1.5 netmask 0xffffff00 broadcast ..."
+        parts = line.split()
+        if len(parts) >= 4 and parts[0] == "inet" and not parts[1].startswith("127."):
+            ip = parts[1]
+            netmask = parts[3] if parts[2] == "netmask" else ""
+            interfaces.append(NetInfo(name="", ip=ip, subnet=netmask))
+    return interfaces
+
+
+async def _gather_linux(ctx: SystemContext) -> None:
+    """Gather system context using Linux commands."""
+    (
+        ctx.hostname,
+        distro_line,
+        ctx.kernel,
+        ctx.arch,
+        cpu_line,
+        mem_line,
+        sudo_check,
+        gateway_line,
+        df_output,
+        ip_output,
+        services_output,
+        docker_output,
+    ) = await asyncio.gather(
+        _run("hostname"),
+        _run("grep PRETTY_NAME /etc/os-release | cut -d'\"' -f2"),
+        _run("uname -r"),
+        _run("uname -m"),
+        _run("lscpu | grep 'Model name' | sed 's/Model name:\\s*//'"),
+        _run("free -b | grep Mem"),
+        _run("sudo -n true 2>/dev/null && echo yes || echo no"),
+        _run("ip -4 route show default | awk '{print $3}'"),
+        _run("df -h --output=target,size,used,avail,pcent -x tmpfs -x devtmpfs -x squashfs 2>/dev/null | tail -n +2"),
+        _run("ip -4 -o addr show | awk '{print $2, $4}'"),
+        _run("systemctl list-units --type=service --state=running --no-pager -q 2>/dev/null | awk '{print $1}' | sed 's/.service$//' | head -20"),
+        _run("docker ps --format '{{.Names}} ({{.Image}})' 2>/dev/null | head -10"),
+    )
+
+    ctx.distro = distro_line or "Unknown"
+    ctx.cpu = cpu_line or "Unknown"
+    ctx.has_sudo = sudo_check.strip() == "yes"
+    ctx.default_gateway = gateway_line
+
+    # Parse memory (free -b output: Mem: total used free shared buff/cache available)
+    if mem_line:
+        parts = mem_line.split()
+        if len(parts) >= 7:
+            try:
+                ctx.ram_total_gb = int(parts[1]) / (1024 ** 3)
+                ctx.ram_available_gb = int(parts[6]) / (1024 ** 3)
+            except (ValueError, IndexError):
+                pass
+
+    ctx.disks = _parse_linux_df(df_output)
+    ctx.network = _parse_linux_ip(ip_output)
+
+    if services_output:
+        ctx.running_services = [s.strip() for s in services_output.splitlines() if s.strip()]
+    if docker_output:
+        ctx.containers = [c.strip() for c in docker_output.splitlines() if c.strip()]
+
+
+async def _gather_macos(ctx: SystemContext) -> None:
+    """Gather system context using macOS commands."""
+    (
+        ctx.hostname,
+        distro_line,
+        ctx.kernel,
+        ctx.arch,
+        cpu_line,
+        ram_total_raw,
+        ram_avail_raw,
+        sudo_check,
+        gateway_line,
+        df_output,
+        ifconfig_output,
+        services_output,
+        docker_output,
+    ) = await asyncio.gather(
+        _run("hostname"),
+        _run("sw_vers -productName -productVersion"),
+        _run("uname -r"),
+        _run("uname -m"),
+        _run("sysctl -n machdep.cpu.brand_string"),
+        _run("sysctl -n hw.memsize"),
+        _run("vm_stat | awk '/Pages free|Pages inactive/ {sum += $NF} END {print sum * 4096}'"),
+        _run("sudo -n true 2>/dev/null && echo yes || echo no"),
+        _run("route -n get default 2>/dev/null | awk '/gateway/{print $2}'"),
+        _run("df -h | grep -vE '^(devfs|map |Filesystem)' | tail -n +1"),
+        _run("ifconfig | grep 'inet '"),
+        _run("launchctl list 2>/dev/null | awk 'NR>1 {print $3}' | head -20"),
+        _run("docker ps --format '{{.Names}} ({{.Image}})' 2>/dev/null | head -10"),
+    )
+
+    ctx.distro = distro_line.replace("\n", " ") if distro_line else "macOS"
+    ctx.cpu = cpu_line or "Unknown"
+    ctx.has_sudo = sudo_check.strip() == "yes"
+    ctx.default_gateway = gateway_line
+
+    # Parse memory
+    if ram_total_raw:
+        try:
+            ctx.ram_total_gb = int(ram_total_raw) / (1024 ** 3)
+        except ValueError:
+            pass
+    if ram_avail_raw:
+        try:
+            ctx.ram_available_gb = int(ram_avail_raw) / (1024 ** 3)
+        except ValueError:
+            pass
+
+    ctx.disks = _parse_macos_df(df_output)
+    ctx.network = _parse_macos_ifconfig(ifconfig_output)
+
+    if services_output:
+        ctx.running_services = [s.strip() for s in services_output.splitlines() if s.strip()]
+    if docker_output:
+        ctx.containers = [c.strip() for c in docker_output.splitlines() if c.strip()]
+
+
+async def gather_system_context() -> SystemContext:
+    """Gather system information. Non-blocking, tolerates failures."""
+    ctx = SystemContext()
+
+    if is_macos():
+        await _gather_macos(ctx)
+    else:
+        await _gather_linux(ctx)
+
+    # Common fields
+    ctx.username = os.environ.get("USER", "unknown")
+    ctx.is_root = os.geteuid() == 0
+    ctx.shell = os.environ.get("SHELL", "/bin/sh")
+    ctx.cwd = os.getcwd()
+
+    # Detect package manager
+    pm_list = ["brew", "apt", "dnf", "yum", "pacman", "zypper", "apk", "emerge"]
+    if not is_macos():
+        # On Linux, don't prioritize brew
+        pm_list = ["apt", "dnf", "yum", "pacman", "zypper", "apk", "emerge", "brew"]
+    for pm in pm_list:
+        check = await _run(f"which {pm} 2>/dev/null")
+        if check:
+            ctx.package_manager = pm
+            break
+
+    # Check common tools
+    tools_to_check = [
+        "docker", "git", "nmap", "curl", "wget", "ssh", "python3",
+        "node", "go", "rsync", "tmux", "vim", "htop", "jq",
+        # Languages & compilers
+        "rustc", "gcc", "g++", "clang", "javac", "ruby", "php", "perl",
+        # Package managers & build tools
+        "pip", "npm", "yarn", "cargo", "composer", "gem", "make", "cmake",
+    ]
+    tool_checks = await asyncio.gather(
+        *[_run(f"which {tool} 2>/dev/null") for tool in tools_to_check]
+    )
+    ctx.installed_tools = {
+        tool: bool(result) for tool, result in zip(tools_to_check, tool_checks)
+    }
+
+    return ctx