claude-smart 0.2.42 → 0.2.44

package/plugin/vendor/reflexio/reflexio/cli/stop_services.py

@@ -0,0 +1,96 @@
+"""Stop reflexio services."""
+
+from __future__ import annotations
+
+import argparse
+
+from dotenv import load_dotenv
+
+from reflexio.cli.run_services import parse_only_flag, resolve_ports
+from reflexio.cli.utils import stop_services
+
+
+def add_arguments(parser: argparse.ArgumentParser) -> None:
+    """Add stop-services arguments to the parser."""
+    parser.add_argument(
+        "--backend-port",
+        type=int,
+        default=None,
+        help="Backend port (default: 8081, env: BACKEND_PORT)",
+    )
+    parser.add_argument(
+        "--docs-port",
+        type=int,
+        default=None,
+        help="Docs port (default: 8082, env: DOCS_PORT)",
+    )
+    parser.add_argument(
+        "--embedding-port",
+        type=int,
+        default=None,
+        help="Embedding service port (default: 8072, env: EMBEDDING_PORT)",
+    )
+    parser.add_argument(
+        "--only",
+        type=str,
+        default=None,
+        help="Comma-separated list of services to stop: backend,docs,embedding",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="SIGKILL immediately (skip graceful shutdown)",
+    )
+
+
+def build_stop_targets(
+    only: set[str],
+    ports: dict[str, int],
+    *,
+    backend_pattern: str = "uvicorn reflexio.server.api:app",
+) -> tuple[dict[str, int], dict[str, str]]:
+    """Build port_map and process_patterns for stopping services.
+
+    Args:
+        only: Set of service names to stop
+        ports: Resolved port map
+        backend_pattern: Process pattern for the backend service
+
+    Returns:
+        Tuple of (port_map, process_patterns)
+    """
+    port_map: dict[str, int] = {}
+    process_patterns: dict[str, str] = {}
+
+    if "backend" in only:
+        port_map["backend"] = ports["backend"]
+        process_patterns["backend"] = backend_pattern
+
+    if "docs" in only:
+        port_map["docs"] = ports["docs"]
+        process_patterns["docs"] = f"next dev.*-p {ports['docs']}"
+
+    if "embedding" in only:
+        port_map["embedding"] = ports["embedding"]
+        process_patterns["embedding"] = "reflexio.server.llm.embedding_service:app"
+
+    return port_map, process_patterns
+
+
+def execute(args: argparse.Namespace) -> None:
+    """Execute the stop-services command."""
+    load_dotenv()
+
+    ports = resolve_ports(
+        args, defaults={"backend": 8081, "docs": 8082, "embedding": 8072}
+    )
+    only = parse_only_flag(args.only, {"backend", "docs", "embedding"})
+    port_map, process_patterns = build_stop_targets(only, ports)
+
+    if not port_map:
+        print("No services selected. Available: backend, docs, embedding")
+        return
+
+    print("Stopping services...")
+    stop_services(port_map, process_patterns, force=args.force)
+    print("All services stopped.")

package/plugin/vendor/reflexio/reflexio/cli/utils.py

@@ -0,0 +1,329 @@
+"""Shared utilities for service process management."""
+
+from __future__ import annotations
+
+import contextlib
+import dataclasses
+import hashlib
+import json
+import os
+import signal
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from collections.abc import Callable
+from pathlib import Path
+
+from reflexio.cli.log_format import format_service_line
+
+
+@dataclasses.dataclass
+class ServiceConfig:
+    """Configuration for a single service to launch."""
+
+    name: str
+    command: list[str]
+    cwd: str | None = None
+    env: dict[str, str] | None = None
+
+
+def get_env_port(name: str, default: int) -> int:
+    """Read a port from an environment variable, falling back to default."""
+    val = os.environ.get(name)
+    if val is not None:
+        try:
+            return int(val)
+        except ValueError:
+            print(f"Warning: invalid {name}={val!r}, using default {default}")
+    return default
+
+
+def find_pids_on_port(port: int) -> list[int]:
+    """Find process IDs listening on the given port using lsof."""
+    try:
+        result = subprocess.run(
+            ["lsof", "-t", f"-i:{port}"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return [
+                int(p) for p in result.stdout.strip().split("\n") if p.strip().isdigit()
+            ]
+    except FileNotFoundError:
+        pass
+    return []
+
+
+def find_pids_by_pattern(pattern: str) -> list[int]:
+    """Find process IDs matching a command pattern using pgrep."""
+    try:
+        result = subprocess.run(
+            ["pgrep", "-f", pattern],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return [
+                int(p) for p in result.stdout.strip().split("\n") if p.strip().isdigit()
+            ]
+    except FileNotFoundError:
+        pass
+    return []
+
+
+def kill_processes(
+    pids: list[int], graceful_timeout: float = 2.0, force: bool = False
+) -> None:
+    """Kill processes: SIGTERM first, then SIGKILL survivors after timeout."""
+    if not pids:
+        return
+
+    unique_pids = list(set(pids))
+    my_pid = os.getpid()
+    unique_pids = [p for p in unique_pids if p != my_pid]
+
+    if not unique_pids:
+        return
+
+    sig = signal.SIGKILL if force else signal.SIGTERM
+    for pid in unique_pids:
+        try:
+            os.kill(pid, sig)
+        except ProcessLookupError:
+            pass
+        except PermissionError:
+            print(f"Warning: no permission to kill PID {pid}")
+
+    if force:
+        return
+
+    time.sleep(graceful_timeout)
+
+    for pid in unique_pids:
+        try:
+            os.kill(pid, signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+        except PermissionError:
+            pass
+
+
+def get_pidfile_path(ports: dict[str, int]) -> Path:
+    """Get a unique pidfile path based on the port combination."""
+    port_str = json.dumps(ports, sort_keys=True)
+    port_hash = hashlib.md5(port_str.encode()).hexdigest()[:8]  # noqa: S324
+    return Path(tempfile.gettempdir()) / f"reflexio_services_{port_hash}.json"
+
+
+def write_pidfile(pidfile: Path, service_pids: dict[str, int]) -> None:
+    """Write service PIDs to the pidfile."""
+    pidfile.write_text(json.dumps(service_pids, indent=2))
+
+
+def read_pidfile(pidfile: Path) -> dict[str, int]:
+    """Read service PIDs from the pidfile. Returns empty dict if not found."""
+    if not pidfile.exists():
+        return {}
+    try:
+        return json.loads(pidfile.read_text())
+    except (json.JSONDecodeError, OSError):  # fmt: skip
+        return {}
+
+
+def remove_pidfile(pidfile: Path) -> None:
+    """Remove the pidfile if it exists."""
+    with contextlib.suppress(OSError):
+        pidfile.unlink(missing_ok=True)
+
+
+# Patterns that indicate a service is ready to accept requests
+_READY_PATTERNS: dict[str, list[str]] = {
+    "backend": ["Application startup complete"],
+    "embedding": ["Application startup complete"],
+    "frontend": ["Ready in"],
+    "docs": ["Ready in"],
+}
+
+# Extra env vars to suppress noise from subprocesses at source
+_NOISE_SUPPRESSION_ENV: dict[str, dict[str, str]] = {
+    "backend": {"LITELLM_LOG": "ERROR"},
+    "embedding": {"LITELLM_LOG": "ERROR"},
+    "frontend": {"NODE_NO_WARNINGS": "1"},
+    "docs": {"NODE_NO_WARNINGS": "1"},
+}
+
+
+def _stream_output(
+    proc: subprocess.Popen[bytes],
+    service_name: str,
+    lock: threading.Lock,
+    ready_event: threading.Event,
+) -> None:
+    """Read subprocess stdout line by line, prefix, and write to stdout.
+
+    Args:
+        proc: The subprocess to read from.
+        service_name: Name of the service for prefixing.
+        lock: Lock to prevent interleaved partial lines.
+        ready_event: Event to set when the service is ready.
+    """
+    ready_patterns = _READY_PATTERNS.get(service_name, [])
+    assert proc.stdout is not None  # noqa: S101
+    for raw_line in proc.stdout:
+        line = raw_line.decode("utf-8", errors="replace").rstrip()
+        if not line:
+            continue
+        formatted = format_service_line(service_name, line)
+        with lock:
+            sys.stdout.write(formatted + "\n")
+            sys.stdout.flush()
+        # Check for ready patterns
+        if not ready_event.is_set() and any(p in line for p in ready_patterns):
+            ready_event.set()
+
+
+def run_services(
+    services: list[ServiceConfig],
+    ports: dict[str, int],
+    *,
+    on_all_ready: Callable[[dict[str, int]], None] | None = None,
+) -> None:
+    """Launch services, pipe output with prefixes, and manage lifecycle.
+
+    Each service's stdout/stderr is captured and prefixed with a colored
+    service tag (e.g., [backend]). A callback is invoked when all services
+    report ready (or after a timeout).
+
+    Args:
+        services: List of service configurations to launch.
+        ports: Port mapping for pidfile identification.
+        on_all_ready: Optional callback invoked with ports when all services are ready.
+    """
+    processes: dict[str, subprocess.Popen[bytes]] = {}
+    threads: list[threading.Thread] = []
+    ready_events: dict[str, threading.Event] = {}
+    output_lock = threading.RLock()
+    pidfile = get_pidfile_path(ports)
+
+    def shutdown(_signum: int | None = None, _frame: object = None) -> None:
+        with output_lock:
+            sys.stdout.write("\nShutting down services...\n")
+            sys.stdout.flush()
+        for proc in processes.values():
+            with contextlib.suppress(OSError):
+                proc.terminate()
+        deadline = time.time() + 3.0
+        for proc in processes.values():
+            remaining = max(0, deadline - time.time())
+            try:
+                proc.wait(timeout=remaining)
+            except subprocess.TimeoutExpired:
+                with contextlib.suppress(OSError):
+                    proc.kill()
+        for t in threads:
+            t.join(timeout=1.0)
+        remove_pidfile(pidfile)
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, shutdown)
+    signal.signal(signal.SIGTERM, shutdown)
+
+    for svc in services:
+        noise_env = _NOISE_SUPPRESSION_ENV.get(svc.name, {})
+        merged_env = {**os.environ, **(svc.env or {}), **noise_env}
+        with output_lock:
+            sys.stdout.write(f"Starting {svc.name}...\n")
+            sys.stdout.flush()
+        proc = subprocess.Popen(
+            svc.command,
+            cwd=svc.cwd,
+            env=merged_env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        )
+        processes[svc.name] = proc
+        ready_event = threading.Event()
+        ready_events[svc.name] = ready_event
+        t = threading.Thread(
+            target=_stream_output,
+            args=(proc, svc.name, output_lock, ready_event),
+            daemon=True,
+        )
+        t.start()
+        threads.append(t)
+        with output_lock:
+            sys.stdout.write(f"  {svc.name} started (PID {proc.pid})\n")
+            sys.stdout.flush()
+
+    # Write pidfile
+    pids = {name: proc.pid for name, proc in processes.items()}
+    write_pidfile(pidfile, pids)
+
+    # Wait for all services to be ready (or timeout with shared deadline)
+    if on_all_ready:
+        deadline = time.monotonic() + 60
+        all_ready = all(
+            evt.wait(timeout=max(0, deadline - time.monotonic()))
+            for evt in ready_events.values()
+        )
+        if all_ready:
+            on_all_ready(ports)
+
+    # Wait for any child to exit
+    try:
+        while processes:
+            for name, proc in list(processes.items()):
+                ret = proc.poll()
+                if ret is not None:
+                    with output_lock:
+                        sys.stdout.write(
+                            format_service_line(name, f"exited with code {ret}") + "\n"
+                        )
+                        sys.stdout.flush()
+                    del processes[name]
+            if processes:
+                time.sleep(0.5)
+    except KeyboardInterrupt:
+        shutdown()
+
+    remove_pidfile(pidfile)
+
+
+def stop_services(
+    port_map: dict[str, int],
+    process_patterns: dict[str, str],
+    force: bool = False,
+) -> None:
+    """Stop services by port and process pattern.
+
+    Args:
+        port_map: Mapping of service name to port number.
+        process_patterns: Mapping of service name to pgrep pattern.
+        force: If True, send SIGKILL immediately instead of graceful shutdown.
+    """
+    pidfile = get_pidfile_path(port_map)
+    saved_pids = read_pidfile(pidfile)
+
+    for name, port in port_map.items():
+        pids_from_port = find_pids_on_port(port)
+        pids_from_pattern = (
+            find_pids_by_pattern(process_patterns[name])
+            if name in process_patterns
+            else []
+        )
+        pids_from_saved = [saved_pids[name]] if name in saved_pids else []
+
+        all_pids = list(set(pids_from_port + pids_from_pattern + pids_from_saved))
+
+        if all_pids:
+            kill_processes(all_pids, force=force)
+            print(f"Stopped {name} (port {port})")
+        else:
+            print(f"{name} (port {port}) not running")
+
+    remove_pidfile(pidfile)

package/plugin/vendor/reflexio/reflexio/client/__init__.py

@@ -0,0 +1,3 @@
+from .client import ReflexioClient
+
+__all__ = ["ReflexioClient"]

package/plugin/vendor/reflexio/reflexio/client/cache.py

@@ -0,0 +1,150 @@
+"""In-memory cache module for Reflexio client."""
+
+import hashlib
+import json
+import threading
+from datetime import datetime, timedelta
+from typing import Any
+
+
+class InMemoryCache:
+    """
+    Thread-safe in-memory cache with time-based expiration.
+
+    Stores function results in memory to avoid redundant API calls.
+    Cache entries expire after a specified TTL (default: 10 minutes).
+    """
+
+    def __init__(self, ttl_seconds: int = 600):
+        """
+        Initialize the in-memory cache.
+
+        Args:
+            ttl_seconds (int): Time-to-live for cache entries in seconds. Default is 600 (10 minutes).
+        """
+        self._cache: dict[str, dict[str, Any]] = {}
+        self._lock = threading.Lock()
+        self._ttl_seconds = ttl_seconds
+
+    def _generate_cache_key(self, method_name: str, **kwargs) -> str:
+        """
+        Generate a unique cache key from method name and parameters.
+
+        Handles datetime objects, None values, and nested dictionaries.
+
+        Args:
+            method_name (str): Name of the cached method
+            **kwargs: Method parameters to include in the cache key
+
+        Returns:
+            str: Unique cache key hash
+        """
+        # Create a normalized representation of the parameters
+        normalized_params = {}
+        for key, value in sorted(kwargs.items()):
+            if isinstance(value, datetime):
+                # Convert datetime to ISO format string
+                normalized_params[key] = value.isoformat()
+            elif value is None:
+                normalized_params[key] = None
+            elif hasattr(value, "model_dump"):
+                # Handle Pydantic models
+                normalized_params[key] = value.model_dump()
+            elif isinstance(value, dict):
+                normalized_params[key] = value
+            else:
+                normalized_params[key] = value
+
+        # Create a stable JSON representation
+        key_data = {"method": method_name, "params": normalized_params}
+        key_string = json.dumps(key_data, sort_keys=True, default=str)
+
+        # Generate hash for the cache key
+        return hashlib.sha256(key_string.encode()).hexdigest()
+
+    def get(self, method_name: str, **kwargs) -> Any | None:
+        """
+        Retrieve a cached value if it exists and is not expired.
+
+        Args:
+            method_name (str): Name of the cached method
+            **kwargs: Method parameters used to generate cache key
+
+        Returns:
+            Optional[Any]: Cached value if found and valid, None otherwise
+        """
+        cache_key = self._generate_cache_key(method_name, **kwargs)
+
+        with self._lock:
+            if cache_key not in self._cache:
+                return None
+
+            entry = self._cache[cache_key]
+
+            # Check if entry has expired
+            if datetime.now() > entry["expires_at"]:
+                # Remove expired entry
+                del self._cache[cache_key]
+                return None
+
+            return entry["data"]
+
+    def set(self, method_name: str, value: Any, **kwargs) -> None:
+        """
+        Store a value in the cache with automatic expiration.
+
+        Args:
+            method_name (str): Name of the cached method
+            value (Any): Value to cache
+            **kwargs: Method parameters used to generate cache key
+        """
+        cache_key = self._generate_cache_key(method_name, **kwargs)
+
+        with self._lock:
+            self._cache[cache_key] = {
+                "data": value,
+                "method_name": method_name,
+                "timestamp": datetime.now(),
+                "expires_at": datetime.now() + timedelta(seconds=self._ttl_seconds),
+            }
+
+            # Cleanup expired entries periodically (every 100 sets)
+            if len(self._cache) % 100 == 0:
+                self._cleanup_expired()
+
+    def clear(self) -> None:
+        """Remove all entries from the cache."""
+        with self._lock:
+            self._cache.clear()
+
+    def invalidate(self, method_name: str) -> int:
+        """Remove all entries cached under a given method name.
+
+        Args:
+            method_name: The method name whose entries should be removed.
+
+        Returns:
+            int: Number of entries removed.
+        """
+        with self._lock:
+            keys_to_remove = [
+                key
+                for key, entry in self._cache.items()
+                if entry.get("method_name") == method_name
+            ]
+            for key in keys_to_remove:
+                del self._cache[key]
+            return len(keys_to_remove)
+
+    def _cleanup_expired(self) -> None:
+        """
+        Remove all expired entries from the cache.
+
+        Note: This method assumes the lock is already acquired by the caller.
+        """
+        now = datetime.now()
+        expired_keys = [
+            key for key, entry in self._cache.items() if now > entry["expires_at"]
+        ]
+        for key in expired_keys:
+            del self._cache[key]