raze-cli 1.0.0__tar.gz

raze_cli-1.0.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: raze-cli
+Version: 1.0.0
+Summary: RAZE CLI - Local-first AI workforce command line interface
+Author-email: Mohammed Alanazi <mtma.1@hotmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mtma1/Raze-1
+Project-URL: Repository, https://github.com/mtma1/Raze-1
+Project-URL: Issues, https://github.com/mtma1/Raze-1/issues
+Keywords: ai,cli,agents,automation,local-first,raze
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.15.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: grpc
+Requires-Dist: grpcio>=1.78.0; extra == "grpc"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+
+# RAZE CLI
+
+RAZE CLI is the local command line entrypoint for the RAZE runtime.
+
+## Install
+
+```bash
+pip install raze-cli
+```
+
+Optional gRPC transport support:
+
+```bash
+pip install "raze-cli[grpc]"
+```
+
+## First run
+
+```bash
+raze setup
+raze doctor
+raze dashboard
+```
+
+## What the CLI expects
+
+- A writable local runtime directory via `RAZE_DATA_DIR` or the default user data path
+- A reachable `raze_core` runtime when you want to use Core-backed commands
+- A separate dashboard build or the dashboard source tree when you want to launch the UI
+- When `grpcio` is installed and Core exposes the localhost control plane, the CLI will prefer gRPC automatically and fall back to REST when needed
+
+## Common commands
+
+```bash
+raze config
+raze list
+raze install research-employee
+raze run research-employee
+raze reset-db --yes
+```

raze_cli-1.0.0/README.md

@@ -0,0 +1,40 @@
+# RAZE CLI
+
+RAZE CLI is the local command line entrypoint for the RAZE runtime.
+
+## Install
+
+```bash
+pip install raze-cli
+```
+
+Optional gRPC transport support:
+
+```bash
+pip install "raze-cli[grpc]"
+```
+
+## First run
+
+```bash
+raze setup
+raze doctor
+raze dashboard
+```
+
+## What the CLI expects
+
+- A writable local runtime directory via `RAZE_DATA_DIR` or the default user data path
+- A reachable `raze_core` runtime when you want to use Core-backed commands
+- A separate dashboard build or the dashboard source tree when you want to launch the UI
+- When `grpcio` is installed and Core exposes the localhost control plane, the CLI will prefer gRPC automatically and fall back to REST when needed
+
+## Common commands
+
+```bash
+raze config
+raze list
+raze install research-employee
+raze run research-employee
+raze reset-db --yes
+```

raze_cli-1.0.0/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "raze-cli"
+version = "1.0.0"
+description = "RAZE CLI - Local-first AI workforce command line interface"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Mohammed Alanazi", email = "mtma.1@hotmail.com" },
+]
+keywords = ["ai", "cli", "agents", "automation", "local-first", "raze"]
+classifiers = [
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "typer>=0.15.0",
+    "rich>=13.0.0",
+    "httpx>=0.28.0",
+    "pyyaml>=6.0",
+]
+
+[project.optional-dependencies]
+grpc = [
+    "grpcio>=1.78.0",
+]
+dev = [
+    "pytest>=8.0.0",
+]
+
+[project.scripts]
+raze = "raze_cli.main:app"
+
+[project.urls]
+Homepage = "https://github.com/mtma1/Raze-1"
+Repository = "https://github.com/mtma1/Raze-1"
+Issues = "https://github.com/mtma1/Raze-1/issues"
+
+[build-system]
+requires = ["setuptools>=75.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+include = ["raze_cli*"]

raze_cli-1.0.0/raze_cli/__init__.py

@@ -0,0 +1,3 @@
+"""RAZE CLI - Local AI workforce platform."""
+
+__version__ = "1.0.0"

raze_cli-1.0.0/raze_cli/api_client.py

@@ -0,0 +1,233 @@
+"""HTTP client for communicating with the local RAZE Core API."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+from raze_cli.grpc_client import RazeGrpcClient
+
+
+DEFAULT_CORE_URL = "http://127.0.0.1:52100"
+FALLBACK_CORE_PORTS = [8400, 8401, 8500, 9100, 9200]
+
+
+class RazeAPIClient:
+    """Client for RAZE Core API."""
+
+    def __init__(self, base_url: str = DEFAULT_CORE_URL):
+        self.base_url = base_url.rstrip("/")
+        self.grpc = RazeGrpcClient()
+
+    def _url(self, path: str) -> str:
+        return f"{self.base_url}{path}"
+
+    def _runtime_state_path(self) -> Path:
+        data_dir = Path(os.environ.get("RAZE_DATA_DIR", Path.home() / ".raze"))
+        return data_dir / "runtime.json"
+
+    def _load_runtime_target(self) -> Optional[str]:
+        path = self._runtime_state_path()
+        if not path.exists():
+            return None
+
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:
+            return None
+
+        host = payload.get("core_host") or "127.0.0.1"
+        port = payload.get("core_port")
+        if isinstance(port, int) and port > 0:
+            return f"http://{host}:{port}"
+        if isinstance(port, str) and port.isdigit():
+            return f"http://{host}:{int(port)}"
+        return None
+
+    def _candidate_ports(self, preferred_port: int, scan_range: int) -> list[int]:
+        candidates: list[int] = []
+
+        runtime_target = self._load_runtime_target()
+        if runtime_target:
+            try:
+                candidates.append(int(runtime_target.rsplit(":", 1)[-1]))
+            except ValueError:
+                pass
+
+        for offset in range(scan_range + 1):
+            candidates.append(preferred_port + offset)
+
+        candidates.extend(FALLBACK_CORE_PORTS)
+
+        deduped: list[int] = []
+        seen: set[int] = set()
+        for port in candidates:
+            if port not in seen:
+                seen.add(port)
+                deduped.append(port)
+        return deduped
+
+    async def health(self) -> dict:
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            resp = await client.get(self._url("/api/health"))
+            resp.raise_for_status()
+            return resp.json()
+
+    async def is_running(self) -> bool:
+        try:
+            await self.health()
+            return True
+        except Exception:
+            return False
+
+    async def discover_core(self, preferred_port: int = 52100, scan_range: int = 20) -> Optional[int]:
+        """Discover a running Core instance using runtime state plus port scanning."""
+        runtime_target = self._load_runtime_target()
+        if runtime_target:
+            try:
+                async with httpx.AsyncClient(timeout=2.0) as client:
+                    resp = await client.get(f"{runtime_target}/api/health")
+                if resp.status_code == 200 and resp.json().get("status") == "healthy":
+                    self.base_url = runtime_target
+                    return int(runtime_target.rsplit(":", 1)[-1])
+            except Exception:
+                pass
+
+        for port in self._candidate_ports(preferred_port, scan_range):
+            try:
+                url = f"http://127.0.0.1:{port}"
+                async with httpx.AsyncClient(timeout=2.0) as client:
+                    resp = await client.get(f"{url}/api/health")
+                if resp.status_code == 200 and resp.json().get("status") == "healthy":
+                    self.base_url = url
+                    payload = resp.json()
+                    return int(payload.get("port") or port)
+            except Exception:
+                continue
+        return None
+
+    async def wait_for_ready(self, timeout: int = 15) -> bool:
+        """Poll the health endpoint until Core is ready or timeout."""
+        for _ in range(timeout * 2):
+            try:
+                port = await self.discover_core()
+                if port is not None:
+                    return True
+            except Exception:
+                pass
+            await asyncio.sleep(0.5)
+        return False
+
+    async def list_providers(self) -> list[dict]:
+        if self.grpc.available():
+            try:
+                return await self.grpc.list_providers()
+            except Exception:
+                pass
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            resp = await client.get(self._url("/api/providers"))
+            resp.raise_for_status()
+            return resp.json()
+
+    async def add_provider(self, data: dict) -> dict:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            resp = await client.post(self._url("/api/providers"), json=data)
+            resp.raise_for_status()
+            return resp.json()
+
+    async def test_provider(self, provider_id: str) -> dict:
+        if self.grpc.available():
+            try:
+                return await self.grpc.test_provider(provider_id)
+            except Exception:
+                pass
+        async with httpx.AsyncClient(timeout=20.0) as client:
+            resp = await client.post(self._url(f"/api/providers/{provider_id}/test"))
+            resp.raise_for_status()
+            return resp.json()
+
+    async def list_employees(self) -> list[dict]:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            resp = await client.get(self._url("/api/employees"))
+            resp.raise_for_status()
+            return resp.json()
+
+    async def install_employee(self, employee_id: str, dev_path: Optional[str] = None) -> dict:
+        data = {"employee_id": employee_id}
+        if dev_path:
+            data["dev_path"] = dev_path
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            resp = await client.post(self._url("/api/employees/install"), json=data)
+            resp.raise_for_status()
+            return resp.json()
+
+    async def run_employee(self, employee_id: str) -> dict:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.post(self._url(f"/api/employees/{employee_id}/run"))
+            resp.raise_for_status()
+            return resp.json()
+
+    async def stop_employee(self, employee_id: str) -> dict:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.post(self._url(f"/api/employees/{employee_id}/stop"))
+            resp.raise_for_status()
+            return resp.json()
+
+    async def uninstall_employee(self, employee_id: str) -> dict:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.delete(self._url(f"/api/employees/{employee_id}"))
+            resp.raise_for_status()
+            return resp.json()
+
+    async def list_registry(self) -> list[dict]:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            resp = await client.get(self._url("/api/registry"))
+            resp.raise_for_status()
+            return resp.json()
+
+    async def run_doctor(self) -> dict:
+        if self.grpc.available():
+            try:
+                return await self.grpc.run_doctor()
+            except Exception:
+                pass
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.get(self._url("/api/doctor"))
+            resp.raise_for_status()
+            return resp.json()
+
+    async def get_logs(self, limit: int = 50, level: Optional[str] = None) -> list[dict]:
+        params = {"limit": limit}
+        if level:
+            params["level"] = level
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            resp = await client.get(self._url("/api/logs"), params=params)
+            resp.raise_for_status()
+            return resp.json()
+
+    async def get_settings(self) -> dict:
+        if self.grpc.available():
+            try:
+                return await self.grpc.get_settings()
+            except Exception:
+                pass
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            resp = await client.get(self._url("/api/settings"))
+            resp.raise_for_status()
+            return resp.json()
+
+    async def list_models(self) -> dict:
+        if self.grpc.available():
+            try:
+                return await self.grpc.list_models()
+            except Exception:
+                pass
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            resp = await client.get(self._url("/api/models"))
+            resp.raise_for_status()
+            return resp.json()

raze_cli-1.0.0/raze_cli/grpc_client.py

@@ -0,0 +1,104 @@
+"""Optional gRPC client for the RAZE internal control plane."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Optional
+
+
+SYSTEM_SERVICE = "raze.v1.SystemService"
+PROVIDERS_SERVICE = "raze.v1.ProvidersService"
+JOBS_SERVICE = "raze.v1.JobsService"
+ACTIONS_SERVICE = "raze.v1.ActionsService"
+
+
+def _method_path(service: str, method: str) -> str:
+    return f"/{service}/{method}"
+
+
+def _dumps(payload: Any) -> bytes:
+    return json.dumps(payload or {}, ensure_ascii=False, sort_keys=True).encode("utf-8")
+
+
+def _loads(payload: bytes | None) -> Any:
+    if not payload:
+        return {}
+    return json.loads(payload.decode("utf-8"))
+
+
+class RazeGrpcClient:
+    def __init__(self):
+        self._grpc = self._import_grpc()
+
+    def _import_grpc(self):
+        try:
+            import grpc
+        except Exception:
+            return None
+        return grpc
+
+    def _runtime_state_path(self) -> Path:
+        data_dir = Path(os.environ.get("RAZE_DATA_DIR", Path.home() / ".raze"))
+        return data_dir / "runtime.json"
+
+    def _load_target(self) -> Optional[str]:
+        if self._grpc is None:
+            return None
+
+        path = self._runtime_state_path()
+        if not path.exists():
+            return None
+
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:
+            return None
+
+        status = str(payload.get("grpc_status") or "").lower()
+        if status not in {"running", "ready"}:
+            return None
+
+        host = payload.get("grpc_host") or payload.get("core_host") or "127.0.0.1"
+        port = payload.get("grpc_port")
+        if isinstance(port, int) and port > 0:
+            return f"{host}:{port}"
+        if isinstance(port, str) and port.isdigit():
+            return f"{host}:{int(port)}"
+        return None
+
+    def available(self) -> bool:
+        return self._load_target() is not None
+
+    async def _call(self, path: str, payload: dict[str, Any] | None = None) -> Any:
+        if self._grpc is None:
+            raise RuntimeError("grpcio is not installed")
+
+        target = self._load_target()
+        if not target:
+            raise RuntimeError("RAZE gRPC control plane is not available")
+
+        async with self._grpc.aio.insecure_channel(target) as channel:
+            method = channel.unary_unary(
+                path,
+                request_serializer=_dumps,
+                response_deserializer=_loads,
+            )
+            return await method(payload or {})
+
+    async def get_settings(self) -> dict[str, Any]:
+        return await self._call(_method_path(SYSTEM_SERVICE, "GetSettings"))
+
+    async def run_doctor(self) -> dict[str, Any]:
+        return await self._call(_method_path(SYSTEM_SERVICE, "RunDoctor"))
+
+    async def list_providers(self) -> list[dict[str, Any]]:
+        payload = await self._call(_method_path(PROVIDERS_SERVICE, "ListProviders"))
+        return payload.get("providers", [])
+
+    async def test_provider(self, provider_id: str) -> dict[str, Any]:
+        return await self._call(_method_path(PROVIDERS_SERVICE, "TestProvider"), {"provider_id": provider_id})
+
+    async def list_models(self) -> dict[str, Any]:
+        return await self._call(_method_path(PROVIDERS_SERVICE, "ListModels"))

raze_cli-1.0.0/raze_cli/main.py

@@ -0,0 +1,618 @@
+"""RAZE CLI entrypoint."""
+
+from __future__ import annotations
+
+import asyncio
+import importlib.util
+import os
+import shutil
+import subprocess
+import sys
+import webbrowser
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import httpx
+import typer
+import yaml
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+from raze_cli.api_client import RazeAPIClient
+
+
+app = typer.Typer(
+    name="raze",
+    help="RAZE - Local-First AI Workforce Platform",
+    no_args_is_help=True,
+)
+console = Console()
+client = RazeAPIClient()
+
+
+def get_raze_dir() -> Path:
+    return Path(os.environ.get("RAZE_DATA_DIR", Path.home() / ".raze"))
+
+
+def get_db_path() -> Path:
+    return get_raze_dir() / "raze.db"
+
+
+def get_runtime_path() -> Path:
+    return get_raze_dir() / "runtime.json"
+
+
+def get_workspace_root() -> Path:
+    return Path(__file__).resolve().parent.parent.parent
+
+
+def get_source_tree_root() -> Optional[Path]:
+    candidate = get_workspace_root()
+    if (candidate / "services" / "core").exists() and (candidate / "apps" / "dashboard").exists():
+        return candidate
+    return None
+
+
+async def _dashboard_running(port: int) -> bool:
+    try:
+        async with httpx.AsyncClient(timeout=2.0) as http:
+            response = await http.get(f"http://127.0.0.1:{port}")
+        return response.status_code < 500
+    except Exception:
+        return False
+
+
+def _render_dashboard_command(port: int = 52000) -> Optional[str]:
+    source_root = get_source_tree_root()
+    if not source_root:
+        return None
+    dashboard_dir = source_root / "apps" / "dashboard"
+    return f"cd {dashboard_dir} && npm run dev -- --port {port}"
+
+
+def _can_launch_installed_core() -> bool:
+    return importlib.util.find_spec("raze_core.main") is not None
+
+
+def _docker_local_status() -> tuple[str, str]:
+    docker_path = shutil.which("docker")
+    if not docker_path:
+        return (
+            "fail",
+            "Docker Desktop is not installed. Install Docker Desktop for Windows before running Docker-backed employees.",
+        )
+
+    try:
+        result = subprocess.run(
+            ["docker", "info"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except Exception as exc:
+        return ("warn", f"Docker is installed but could not be checked: {exc}")
+
+    if result.returncode == 0:
+        return ("pass", f"Docker Desktop is running ({docker_path})")
+
+    stderr = (result.stderr or result.stdout or "").strip()
+    lowered = stderr.lower()
+    if "createfile" in lowered or "pipe/docker_engine" in lowered or "npipe" in lowered:
+        return (
+            "warn",
+            "Docker Desktop is installed, but the Docker engine pipe is unavailable. Start Docker Desktop and wait for 'Engine running'.",
+        )
+    if "cannot connect to the docker daemon" in lowered or "is the docker daemon running" in lowered:
+        return (
+            "warn",
+            "Docker is installed, but the Docker engine is not running. Start Docker Desktop and retry.",
+        )
+    return ("warn", f"Docker is installed but not ready: {stderr or 'unknown error'}")
+
+
+@app.command()
+def setup():
+    """First-time setup: configure your RAZE environment."""
+    console.print(Panel.fit(
+        "[bold cyan]RAZE[/bold cyan] - First-time setup",
+        border_style="cyan",
+    ))
+
+    raze_dir = get_raze_dir()
+    raze_dir.mkdir(parents=True, exist_ok=True)
+    console.print(f"  Data directory: [dim]{raze_dir}[/dim]")
+
+    config_path = raze_dir / "config.yaml"
+    if config_path.exists():
+        if Confirm.ask("  Config already exists. Overwrite?", default=False):
+            _create_config(config_path)
+        else:
+            console.print("  Keeping existing config.")
+    else:
+        _create_config(config_path)
+
+    console.print()
+    if Confirm.ask("  Open the local dashboard after setup?", default=True):
+        dashboard()
+
+
+def _create_config(config_path: Path):
+    console.print()
+    console.print("  Configure your LLM provider:")
+    console.print("  1. OpenAI")
+    console.print("  2. Ollama (local)")
+    console.print("  3. Anthropic")
+    console.print("  4. Google Gemini")
+    console.print("  5. Groq")
+    console.print("  6. xAI")
+    console.print("  7. Mistral")
+    console.print("  8. OpenAI-compatible endpoint")
+    console.print("  9. Custom endpoint")
+
+    choice = Prompt.ask("  Select provider", choices=["1", "2", "3", "4", "5", "6", "7", "8", "9"], default="1")
+
+    if choice == "1":
+        provider_type = "openai"
+        name = Prompt.ask("  Provider name", default="OpenAI")
+        base_url = Prompt.ask("  Base URL", default="https://api.openai.com/v1")
+        api_key = Prompt.ask("  API key", password=True)
+        model = Prompt.ask("  Model", default="gpt-4o")
+    elif choice == "2":
+        provider_type = "ollama"
+        name = "Ollama"
+        base_url = Prompt.ask("  Ollama URL", default="http://localhost:11434")
+        api_key = None
+        model = Prompt.ask("  Model", default="qwen3.5:9b")
+    elif choice == "3":
+        provider_type = "anthropic"
+        name = Prompt.ask("  Provider name", default="Anthropic")
+        base_url = Prompt.ask("  Base URL", default="https://api.anthropic.com/v1")
+        api_key = Prompt.ask("  API key", password=True)
+        model = Prompt.ask("  Model", default="claude-sonnet-4-6")
+    elif choice == "4":
+        provider_type = "gemini"
+        name = Prompt.ask("  Provider name", default="Google Gemini")
+        base_url = Prompt.ask("  Base URL", default="https://generativelanguage.googleapis.com/v1beta")
+        api_key = Prompt.ask("  API key", password=True)
+        model = Prompt.ask("  Model", default="gemini-3-flash-preview")
+    elif choice == "5":
+        provider_type = "groq"
+        name = Prompt.ask("  Provider name", default="Groq")
+        base_url = Prompt.ask("  Base URL", default="https://api.groq.com/openai/v1")
+        api_key = Prompt.ask("  API key", password=True)
+        model = Prompt.ask("  Model", default="llama-3.1-8b-instant")
+    elif choice == "6":
+        provider_type = "xai"
+        name = Prompt.ask("  Provider name", default="xAI")
+        base_url = Prompt.ask("  Base URL", default="https://api.x.ai/v1")
+        api_key = Prompt.ask("  API key", password=True)
+        model = Prompt.ask("  Model", default="grok-4-1-fast-non-reasoning")
+    elif choice == "7":
+        provider_type = "mistral"
+        name = Prompt.ask("  Provider name", default="Mistral")
+        base_url = Prompt.ask("  Base URL", default="https://api.mistral.ai/v1")
+        api_key = Prompt.ask("  API key", password=True)
+        model = Prompt.ask("  Model", default="mistral-large-latest")
+    elif choice == "8":
+        provider_type = "openai_compatible"
+        name = Prompt.ask("  Provider name", default="OpenAI-compatible")
+        base_url = Prompt.ask("  Base URL", default="https://example.com/v1")
+        api_key = Prompt.ask("  API key", password=True)
+        model = Prompt.ask("  Model", default="model-name")
+    else:
+        provider_type = "custom"
+        name = Prompt.ask("  Provider name", default="Custom")
+        base_url = Prompt.ask("  Base URL")
+        api_key = Prompt.ask("  API key (optional)", password=True, default="") or None
+        model = Prompt.ask("  Model")
+
+    provider_id = name.lower().replace(" ", "-")
+
+    # Validate URL format before persisting
+    base_url = base_url.strip().rstrip("/")
+    if not base_url.startswith(("http://", "https://")):
+        console.print(f"  [yellow]Warning: Base URL '{base_url}' does not start with http:// or https://[/yellow]")
+        console.print("  [yellow]This may cause connection failures. Please verify the URL.[/yellow]")
+
+    config = {
+        "providers": [{
+            "id": provider_id,
+            "name": name,
+            "type": provider_type,
+            "base_url": base_url,
+            "api_key": api_key,
+            "model": model,
+            "is_default": True,
+        }],
+        "default_provider": provider_id,
+        "fallback_provider": None,
+        "core_version": "1.0.0",
+    }
+
+    with open(config_path, "w", encoding="utf-8") as handle:
+        yaml.dump(config, handle, default_flow_style=False)
+
+    console.print(f"  Config saved to [dim]{config_path}[/dim]")
+
+
+@app.command()
+def dashboard():
+    """Ensure Core is running, then open the local dashboard URL."""
+    console.print(Panel.fit(
+        "[bold magenta]RAZE[/bold magenta] - Dashboard launcher",
+        border_style="magenta",
+    ))
+
+    console.print("  Checking for a running Core instance...")
+    discovered_port = asyncio.run(client.discover_core())
+
+    if discovered_port:
+        console.print(f"  Core found on [cyan]{discovered_port}[/cyan]")
+    else:
+        if not _can_launch_installed_core():
+            console.print("  [red]Core is not running and raze-core is not installed in this environment.[/red]")
+            source_root = get_source_tree_root()
+            if source_root:
+                console.print(f"  [dim]Run manually: cd {source_root / 'services' / 'core'} && python -m raze_core.main[/dim]")
+            else:
+                console.print("  [dim]Install the runtime package, then run: python -m raze_core.main[/dim]")
+            raise typer.Exit(1)
+
+        console.print("  Core is not running. Starting it in the background...")
+        source_root = get_source_tree_root()
+        core_dir = source_root / "services" / "core" if source_root else None
+        try:
+            command = [sys.executable, "-m", "raze_core.main"]
+            if sys.platform == "win32":
+                creation_flags = subprocess.CREATE_NO_WINDOW | subprocess.DETACHED_PROCESS
+                proc = subprocess.Popen(
+                    command,
+                    cwd=str(core_dir) if core_dir else None,
+                    env=os.environ.copy(),
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    creationflags=creation_flags,
+                )
+            else:
+                proc = subprocess.Popen(
+                    command,
+                    cwd=str(core_dir) if core_dir else None,
+                    env=os.environ.copy(),
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    start_new_session=True,
+                )
+            console.print(f"  Core process started (PID {proc.pid}). Waiting for readiness...")
+        except Exception as exc:
+            console.print(f"  [red]Failed to start Core: {exc}[/red]")
+            if core_dir:
+                console.print(f"  [dim]Run manually: cd {core_dir} && python -m raze_core.main[/dim]")
+            else:
+                console.print("  [dim]Run manually: python -m raze_core.main[/dim]")
+            raise typer.Exit(1)
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("  Waiting for Core to become ready...", total=None)
+            ready = asyncio.run(client.wait_for_ready(timeout=20))
+            if not ready:
+                progress.update(task, description="  Core did not respond in time")
+                console.print("  [yellow]Core may still be starting. Check the Core logs directly.[/yellow]")
+                if core_dir:
+                    console.print(f"  [dim]Run manually: cd {core_dir} && python -m raze_core.main[/dim]")
+                else:
+                    console.print("  [dim]Run manually: python -m raze_core.main[/dim]")
+                raise typer.Exit(1)
+            progress.update(task, description="  Core is ready")
+
+        discovered_port = asyncio.run(client.discover_core())
+
+    if not discovered_port:
+        console.print("  [red]Could not determine the active Core port.[/red]")
+        raise typer.Exit(1)
+
+    settings = None
+    try:
+        settings = asyncio.run(client.get_settings())
+        console.print(f"  Core API: [cyan]{settings['core_url']}[/cyan]")
+        if settings["core_port"] != settings["preferred_core_port"]:
+            console.print(
+                f"  [yellow]Preferred port {settings['preferred_core_port']} was unavailable. "
+                f"Core is using {settings['core_port']} instead.[/yellow]"
+            )
+        console.print(f"  Database: [dim]{settings['db_path']}[/dim]")
+    except Exception:
+        console.print(f"  Core API: [cyan]http://127.0.0.1:{discovered_port}[/cyan]")
+
+    dashboard_port = int(settings["dashboard_port"]) if settings else 52000
+    dashboard_url = f"http://localhost:{dashboard_port}"
+    dashboard_running = asyncio.run(_dashboard_running(dashboard_port))
+
+    if not dashboard_running:
+        console.print(f"  [yellow]Dashboard dev server is not running on port {dashboard_port}.[/yellow]")
+        dashboard_command = _render_dashboard_command(dashboard_port)
+        if dashboard_command:
+            console.print("  Start it in a new terminal:")
+            console.print(f"  [dim]{dashboard_command}[/dim]")
+            console.print("  The dashboard proxy reads the active Core port from the RAZE runtime state.")
+        else:
+            console.print("  [yellow]This CLI package does not include the dashboard dev server.[/yellow]")
+            console.print("  Start the dashboard from the source tree or open a packaged dashboard build if you distribute one separately.")
+        return
+
+    console.print(f"  Opening dashboard: [bold cyan]{dashboard_url}[/bold cyan]")
+    webbrowser.open(dashboard_url)
+
+
+@app.command()
+def install(
+    employee: str = typer.Argument(..., help="Employee ID to install"),
+    dev: Optional[str] = typer.Option(None, "--dev", help="Local path for dev mode install"),
+):
+    """Install an employee from the curated registry."""
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task(f"Installing {employee}...", total=None)
+        try:
+            result = asyncio.run(client.install_employee(employee, dev))
+            progress.update(task, description=f"Installed {result['name']} v{result['version']}")
+        except Exception as exc:
+            progress.update(task, description=f"Failed: {exc}")
+            raise typer.Exit(1)
+
+
+@app.command()
+def run(employee: str = typer.Argument(..., help="Employee ID to run")):
+    """Start a Docker-backed employee."""
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task(f"Starting {employee}...", total=None)
+        try:
+            result = asyncio.run(client.run_employee(employee))
+            progress.update(task, description=f"{result['name']} is {result['status']} on port {result.get('port', '?')}")
+        except Exception as exc:
+            progress.update(task, description=f"Failed: {exc}")
+            raise typer.Exit(1)
+
+
+@app.command()
+def stop(employee: str = typer.Argument(..., help="Employee ID to stop")):
+    """Stop a running employee."""
+    try:
+        result = asyncio.run(client.stop_employee(employee))
+        console.print(f"  Stopped {result['name']}")
+    except Exception as exc:
+        console.print(f"  Failed: {exc}")
+        raise typer.Exit(1)
+
+
+@app.command(name="list")
+def list_cmd(
+    registry: bool = typer.Option(False, "--registry", help="Show available employees from the registry"),
+):
+    """List installed employees or browse the registry."""
+    if registry:
+        try:
+            entries = asyncio.run(client.list_registry())
+        except Exception as exc:
+            console.print(f"  Failed to connect to Core: {exc}")
+            raise typer.Exit(1)
+
+        table = Table(title="RAZE Employee Registry")
+        table.add_column("ID", style="cyan")
+        table.add_column("Name")
+        table.add_column("Version")
+        table.add_column("Installed", justify="center")
+
+        for entry in entries:
+            table.add_row(
+                entry["id"],
+                entry["name"],
+                entry["version"],
+                "yes" if entry.get("installed") else "",
+            )
+        console.print(table)
+        return
+
+    try:
+        employees = asyncio.run(client.list_employees())
+    except Exception as exc:
+        console.print(f"  Failed to connect to Core: {exc}")
+        raise typer.Exit(1)
+
+    if not employees:
+        console.print("  No employees installed. Run [cyan]raze install <employee>[/cyan]")
+        return
+
+    table = Table(title="Installed Employees")
+    table.add_column("ID", style="cyan")
+    table.add_column("Name")
+    table.add_column("Version")
+    table.add_column("Status")
+    table.add_column("Port", justify="right")
+
+    for employee in employees:
+        table.add_row(
+            employee["id"],
+            employee["name"],
+            employee["version"],
+            employee["status"],
+            str(employee.get("port", "")),
+        )
+    console.print(table)
+
+
+@app.command()
+def doctor():
+    """Run system diagnostics."""
+    console.print(Panel.fit(
+        "[bold cyan]RAZE[/bold cyan] Doctor",
+        border_style="cyan",
+    ))
+
+    try:
+        report = asyncio.run(client.run_doctor())
+    except Exception:
+        console.print("  Core is not running. Running local checks only...")
+        _run_local_doctor()
+        return
+
+    overall = report["overall"]
+    color = {"healthy": "green", "degraded": "yellow", "unhealthy": "red"}.get(overall, "white")
+    console.print(f"  Overall: [{color}]{overall.upper()}[/{color}]")
+    console.print()
+
+    for check in report["checks"]:
+        icon = {"pass": "OK", "warn": "WARN", "fail": "FAIL"}.get(check["status"], "?")
+        tone = {"pass": "green", "warn": "yellow", "fail": "red"}.get(check["status"], "white")
+        console.print(f"  [{tone}]{icon}[/{tone}] {check['name']}: {check['message']}")
+        if check.get("details"):
+            console.print(f"    [dim]{check['details']}[/dim]")
+
+
+def _run_local_doctor():
+    console.print(f"  Python: {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}")
+    console.print(f"  Platform: {sys.platform}")
+
+    docker_status, docker_message = _docker_local_status()
+    docker_color = {"pass": "green", "warn": "yellow", "fail": "red"}.get(docker_status, "white")
+    console.print(f"  [{docker_color}]Docker:[/{docker_color}] {docker_message}")
+
+    config_path = get_raze_dir() / "config.yaml"
+    if config_path.exists():
+        console.print(f"  Config: {config_path}")
+    else:
+        console.print("  Config: not found. Run [cyan]raze setup[/cyan]")
+
+    console.print(f"  Database: {get_db_path()}")
+    runtime_path = get_runtime_path()
+    if runtime_path.exists():
+        console.print(f"  Runtime state: {runtime_path}")
+
+
+@app.command()
+def update():
+    """Check for RAZE updates."""
+    console.print("  Checking for updates...")
+    console.print("  You are running RAZE v1.0.0")
+
+
+@app.command()
+def config():
+    """Show current local RAZE configuration paths and provider settings."""
+    config_path = get_raze_dir() / "config.yaml"
+    console.print(Panel.fit(
+        "[bold cyan]RAZE[/bold cyan] Configuration",
+        border_style="cyan",
+    ))
+
+    if not config_path.exists():
+        console.print("  No configuration found. Run [cyan]raze setup[/cyan]")
+        raise typer.Exit(1)
+
+    with open(config_path, encoding="utf-8") as handle:
+        data = yaml.safe_load(handle) or {}
+
+    for provider in data.get("providers", []):
+        console.print(f"  Provider: [cyan]{provider['name']}[/cyan] ({provider['type']})")
+        console.print(f"    Base URL: {provider['base_url']}")
+        console.print(f"    Model: {provider['model']}")
+        console.print(f"    API Key: {'configured' if provider.get('api_key') else 'not set'}")
+
+    console.print(f"\n  Config file: [dim]{config_path}[/dim]")
+    console.print(f"  Data dir: [dim]{get_raze_dir()}[/dim]")
+    console.print(f"  Database: [dim]{get_db_path()}[/dim]")
+    console.print(f"  Runtime state: [dim]{get_runtime_path()}[/dim]")
+
+
+@app.command()
+def status():
+    """Show the current local runtime status and important paths."""
+    console.print(Panel.fit(
+        "[bold cyan]RAZE[/bold cyan] Status",
+        border_style="cyan",
+    ))
+
+    raze_dir = get_raze_dir()
+    runtime_path = get_runtime_path()
+    console.print(f"  Data dir: [dim]{raze_dir}[/dim]")
+    console.print(f"  Config: [dim]{raze_dir / 'config.yaml'}[/dim]")
+    console.print(f"  Database: [dim]{get_db_path()}[/dim]")
+    console.print(f"  Runtime state: [dim]{runtime_path}[/dim]")
+
+    docker_status, docker_message = _docker_local_status()
+    docker_color = {"pass": "green", "warn": "yellow", "fail": "red"}.get(docker_status, "white")
+    console.print(f"  [{docker_color}]Docker:[/{docker_color}] {docker_message}")
+
+    discovered_port = asyncio.run(client.discover_core())
+    if discovered_port:
+        console.print(f"  Core: [green]running[/green] on [cyan]{client.base_url}[/cyan]")
+        try:
+            settings = asyncio.run(client.get_settings())
+            console.print(f"  Dashboard port: [cyan]{settings['dashboard_port']}[/cyan]")
+            console.print(f"  gRPC status: [dim]{settings.get('grpc_status', 'disabled')}[/dim]")
+        except Exception as exc:
+            console.print(f"  [yellow]Core is reachable but settings lookup failed: {exc}[/yellow]")
+    else:
+        console.print("  [yellow]Core is not currently responding.[/yellow]")
+        source_root = get_source_tree_root()
+        if source_root:
+            console.print(f"  [dim]Manual Core start: cd {source_root / 'services' / 'core'} && python -m raze_core.main[/dim]")
+
+    dashboard_command = _render_dashboard_command()
+    if dashboard_command:
+        console.print(f"  [dim]Dashboard dev command: {dashboard_command}[/dim]")
+
+
+@app.command("reset-db")
+def reset_db(
+    yes: bool = typer.Option(False, "--yes", help="Reset without interactive confirmation"),
+    backup: bool = typer.Option(True, "--backup/--no-backup", help="Backup the existing database first"),
+):
+    """Dev-safe local database reset."""
+    db_path = get_db_path()
+    if not db_path.exists():
+        console.print(f"  Database does not exist yet: [dim]{db_path}[/dim]")
+        return
+
+    if not yes:
+        confirmed = Confirm.ask(
+            f"  Reset the local database at {db_path}? This is intended for disposable dev data only.",
+            default=False,
+        )
+        if not confirmed:
+            console.print("  Database reset cancelled.")
+            return
+
+    try:
+        if backup:
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
+            backup_path = db_path.with_name(f"raze.db.backup-{timestamp}")
+            db_path.replace(backup_path)
+            console.print(f"  Database moved to [dim]{backup_path}[/dim]")
+        else:
+            db_path.unlink()
+            console.print(f"  Deleted [dim]{db_path}[/dim]")
+    except PermissionError:
+        console.print("  [red]Could not reset the database because it is in use. Stop RAZE Core first.[/red]")
+        raise typer.Exit(1)
+
+    console.print("  Local database reset complete. Restart RAZE Core to recreate the schema.")
+
+
+if __name__ == "__main__":
+    app()

raze_cli-1.0.0/raze_cli.egg-info/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: raze-cli
+Version: 1.0.0
+Summary: RAZE CLI - Local-first AI workforce command line interface
+Author-email: Mohammed Alanazi <mtma.1@hotmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mtma1/Raze-1
+Project-URL: Repository, https://github.com/mtma1/Raze-1
+Project-URL: Issues, https://github.com/mtma1/Raze-1/issues
+Keywords: ai,cli,agents,automation,local-first,raze
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.15.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: grpc
+Requires-Dist: grpcio>=1.78.0; extra == "grpc"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+
+# RAZE CLI
+
+RAZE CLI is the local command line entrypoint for the RAZE runtime.
+
+## Install
+
+```bash
+pip install raze-cli
+```
+
+Optional gRPC transport support:
+
+```bash
+pip install "raze-cli[grpc]"
+```
+
+## First run
+
+```bash
+raze setup
+raze doctor
+raze dashboard
+```
+
+## What the CLI expects
+
+- A writable local runtime directory via `RAZE_DATA_DIR` or the default user data path
+- A reachable `raze_core` runtime when you want to use Core-backed commands
+- A separate dashboard build or the dashboard source tree when you want to launch the UI
+- When `grpcio` is installed and Core exposes the localhost control plane, the CLI will prefer gRPC automatically and fall back to REST when needed
+
+## Common commands
+
+```bash
+raze config
+raze list
+raze install research-employee
+raze run research-employee
+raze reset-db --yes
+```

raze_cli-1.0.0/raze_cli.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+raze_cli/__init__.py
+raze_cli/api_client.py
+raze_cli/grpc_client.py
+raze_cli/main.py
+raze_cli.egg-info/PKG-INFO
+raze_cli.egg-info/SOURCES.txt
+raze_cli.egg-info/dependency_links.txt
+raze_cli.egg-info/entry_points.txt
+raze_cli.egg-info/requires.txt
+raze_cli.egg-info/top_level.txt
+tests/test_cli_runtime_helpers.py
+tests/test_grpc_client.py

raze_cli-1.0.0/raze_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

raze_cli-1.0.0/raze_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+raze = raze_cli.main:app

raze_cli-1.0.0/raze_cli.egg-info/requires.txt

@@ -0,0 +1,10 @@
+typer>=0.15.0
+rich>=13.0.0
+httpx>=0.28.0
+pyyaml>=6.0
+
+[dev]
+pytest>=8.0.0
+
+[grpc]
+grpcio>=1.78.0

raze_cli-1.0.0/raze_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+raze_cli

raze_cli-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

raze_cli-1.0.0/tests/test_cli_runtime_helpers.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "cli"))
+
+from raze_cli import main  # noqa: E402
+
+
+def test_get_source_tree_root_detects_expected_layout(monkeypatch, tmp_path: Path):
+    workspace = tmp_path / "raze"
+    (workspace / "services" / "core").mkdir(parents=True)
+    (workspace / "apps" / "dashboard").mkdir(parents=True)
+
+    monkeypatch.setattr(main, "get_workspace_root", lambda: workspace)
+
+    assert main.get_source_tree_root() == workspace
+
+
+def test_render_dashboard_command_returns_none_without_source_tree(monkeypatch):
+    monkeypatch.setattr(main, "get_source_tree_root", lambda: None)
+
+    assert main._render_dashboard_command(52000) is None
+
+
+def test_render_dashboard_command_uses_dashboard_source_dir(monkeypatch, tmp_path: Path):
+    workspace = tmp_path / "raze"
+    dashboard_dir = workspace / "apps" / "dashboard"
+    dashboard_dir.mkdir(parents=True)
+    (workspace / "services" / "core").mkdir(parents=True)
+
+    monkeypatch.setattr(main, "get_source_tree_root", lambda: workspace)
+
+    command = main._render_dashboard_command(52000)
+    assert command == f"cd {dashboard_dir} && npm run dev -- --port 52000"

raze_cli-1.0.0/tests/test_grpc_client.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "cli"))
+
+from raze_cli.api_client import RazeAPIClient  # noqa: E402
+from raze_cli.grpc_client import RazeGrpcClient  # noqa: E402
+
+
+@pytest.mark.asyncio
+async def test_grpc_client_reads_runtime_target(monkeypatch, tmp_path: Path):
+    calls: list[tuple[str, dict]] = []
+
+    class FakeMethod:
+        def __init__(self, path: str):
+            self.path = path
+
+        async def __call__(self, payload: dict):
+            calls.append((self.path, payload))
+            return {"path": self.path}
+
+    class FakeChannel:
+        def __init__(self, target: str):
+            self.target = target
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, exc_type, exc, tb):
+            return False
+
+        def unary_unary(self, path: str, request_serializer=None, response_deserializer=None):
+            return FakeMethod(path)
+
+    fake_grpc = SimpleNamespace(aio=SimpleNamespace(insecure_channel=lambda target: FakeChannel(target)))
+
+    monkeypatch.setenv("RAZE_DATA_DIR", str(tmp_path))
+    runtime_path = tmp_path / "runtime.json"
+    runtime_path.write_text(
+        json.dumps(
+            {
+                "grpc_host": "127.0.0.1",
+                "grpc_port": 52110,
+                "grpc_status": "running",
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    client = RazeGrpcClient()
+    client._grpc = fake_grpc
+
+    result = await client.get_settings()
+
+    assert client.available() is True
+    assert result["path"] == "/raze.v1.SystemService/GetSettings"
+    assert calls == [("/raze.v1.SystemService/GetSettings", {})]
+
+
+@pytest.mark.asyncio
+async def test_api_client_prefers_grpc_when_available():
+    class FakeGrpcClient:
+        def available(self):
+            return True
+
+        async def get_settings(self):
+            return {"transport": "grpc"}
+
+    client = RazeAPIClient()
+    client.grpc = FakeGrpcClient()
+
+    result = await client.get_settings()
+
+    assert result == {"transport": "grpc"}