scitex 2.17.0__py3-none-any.whl → 2.17.4__py3-none-any.whl

scitex/_dev/_ssh.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-02-02
+# File: scitex/_dev/_ssh.py
+
+"""SSH-based remote version checking for scitex ecosystem."""
+
+from __future__ import annotations
+
+import subprocess
+from typing import Any
+
+from ._config import DevConfig, HostConfig, get_enabled_hosts, load_config
+
+
+def get_remote_version(host: HostConfig, package: str) -> dict[str, Any]:
+    """Get version of a package on a remote host via SSH.
+
+    Parameters
+    ----------
+    host : HostConfig
+        Host configuration.
+    package : str
+        Package name (PyPI name).
+
+    Returns
+    -------
+    dict
+        Version info with keys: installed, status, error (if any).
+    """
+    # Build SSH command
+    ssh_args = ["ssh"]
+
+    if host.ssh_key:
+        ssh_args.extend(["-i", host.ssh_key])
+
+    if host.port != 22:
+        ssh_args.extend(["-p", str(host.port)])
+
+    # Add connection options for non-interactive use
+    ssh_args.extend(
+        [
+            "-o",
+            "BatchMode=yes",
+            "-o",
+            "StrictHostKeyChecking=accept-new",
+            "-o",
+            "ConnectTimeout=5",
+        ]
+    )
+
+    ssh_target = f"{host.user}@{host.hostname}"
+    ssh_args.append(ssh_target)
+
+    # Python command to get version
+    python_cmd = f"""python3 -c "
+try:
+    from importlib.metadata import version
+    print(version('{package}'))
+except Exception as e:
+    print('ERROR:' + str(e))
+"
+"""
+    ssh_args.append(python_cmd)
+
+    try:
+        result = subprocess.run(
+            ssh_args,
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+
+        output = result.stdout.strip()
+
+        if result.returncode != 0:
+            error = result.stderr.strip() or "SSH connection failed"
+            return {
+                "installed": None,
+                "status": "error",
+                "error": error,
+            }
+
+        if output.startswith("ERROR:"):
+            return {
+                "installed": None,
+                "status": "not_installed",
+                "error": output[6:],
+            }
+
+        return {
+            "installed": output,
+            "status": "ok",
+        }
+
+    except subprocess.TimeoutExpired:
+        return {
+            "installed": None,
+            "status": "timeout",
+            "error": "SSH connection timed out",
+        }
+    except Exception as e:
+        return {
+            "installed": None,
+            "status": "error",
+            "error": str(e),
+        }
+
+
+def get_remote_versions(
+    host: HostConfig,
+    packages: list[str],
+) -> dict[str, dict[str, Any]]:
+    """Get versions of multiple packages on a remote host.
+
+    Parameters
+    ----------
+    host : HostConfig
+        Host configuration.
+    packages : list[str]
+        List of package names.
+
+    Returns
+    -------
+    dict
+        Package name -> version info mapping.
+    """
+    # Build SSH command that checks all packages at once
+    ssh_args = ["ssh"]
+
+    if host.ssh_key:
+        ssh_args.extend(["-i", host.ssh_key])
+
+    if host.port != 22:
+        ssh_args.extend(["-p", str(host.port)])
+
+    ssh_args.extend(
+        [
+            "-o",
+            "BatchMode=yes",
+            "-o",
+            "StrictHostKeyChecking=accept-new",
+            "-o",
+            "ConnectTimeout=5",
+        ]
+    )
+
+    ssh_target = f"{host.user}@{host.hostname}"
+    ssh_args.append(ssh_target)
+
+    # Build Python command to check all packages (installed + toml)
+    # Use base64 encoding to avoid shell escaping issues
+    import base64
+
+    packages_list = repr(packages)
+    python_script = f"""
+import json
+from importlib.metadata import version
+from pathlib import Path
+import re
+
+def get_toml_version(pkg):
+    pkg_dir_names = [pkg, pkg.replace("-", "_"), pkg.replace("_", "-")]
+    if pkg == "scitex":
+        pkg_dir_names.append("scitex-python")
+    for dir_name in pkg_dir_names:
+        toml_path = Path.home() / "proj" / dir_name / "pyproject.toml"
+        if toml_path.exists():
+            try:
+                content = toml_path.read_text()
+                match = re.search(r'^version\\s*=\\s*["\\'](.*?)["\\']\\s*$', content, re.MULTILINE)
+                if match:
+                    return match.group(1)
+            except Exception:
+                pass
+    return None
+
+results = {{}}
+for pkg in {packages_list}:
+    result = {{"installed": None, "toml": None, "status": "not_installed"}}
+    try:
+        result["installed"] = version(pkg)
+        result["status"] = "ok"
+    except Exception as e:
+        result["error"] = str(e)
+    result["toml"] = get_toml_version(pkg)
+    results[pkg] = result
+print(json.dumps(results))
+"""
+    encoded = base64.b64encode(python_script.encode()).decode()
+    python_cmd = (
+        f"python3 -c \"import base64;exec(base64.b64decode('{encoded}').decode())\""
+    )
+    ssh_args.append(python_cmd)
+
+    try:
+        result = subprocess.run(
+            ssh_args,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        if result.returncode != 0:
+            error = result.stderr.strip() or "SSH connection failed"
+            return {
+                pkg: {"installed": None, "status": "error", "error": error}
+                for pkg in packages
+            }
+
+        import json
+        from typing import cast
+
+        try:
+            return cast(dict[str, dict[str, Any]], json.loads(result.stdout.strip()))
+        except json.JSONDecodeError:
+            return {
+                pkg: {
+                    "installed": None,
+                    "status": "error",
+                    "error": f"Invalid response: {result.stdout[:100]}",
+                }
+                for pkg in packages
+            }
+
+    except subprocess.TimeoutExpired:
+        return {
+            pkg: {"installed": None, "status": "timeout", "error": "SSH timed out"}
+            for pkg in packages
+        }
+    except Exception as e:
+        return {
+            pkg: {"installed": None, "status": "error", "error": str(e)}
+            for pkg in packages
+        }
+
+
+def check_all_hosts(
+    packages: list[str] | None = None,
+    hosts: list[str] | None = None,
+    config: DevConfig | None = None,
+) -> dict[str, dict[str, dict[str, Any]]]:
+    """Check versions on all enabled hosts.
+
+    Parameters
+    ----------
+    packages : list[str] | None
+        List of package names. If None, uses ecosystem packages.
+    hosts : list[str] | None
+        List of host names to check. If None, checks all enabled hosts.
+    config : DevConfig | None
+        Configuration to use. If None, loads default config.
+
+    Returns
+    -------
+    dict
+        Mapping: host_name -> package_name -> version_info
+    """
+    if config is None:
+        config = load_config()
+
+    if packages is None:
+        from ._ecosystem import get_all_packages
+
+        packages = get_all_packages()
+
+    # Get pypi names for packages
+    from ._ecosystem import ECOSYSTEM
+
+    pypi_names = []
+    name_map = {}  # pypi_name -> package_name
+    for pkg in packages:
+        if pkg in ECOSYSTEM:
+            pypi_name = ECOSYSTEM[pkg].get("pypi_name", pkg)
+        else:
+            pypi_name = pkg
+        pypi_names.append(pypi_name)
+        name_map[pypi_name] = pkg
+
+    # Get enabled hosts
+    enabled_hosts = get_enabled_hosts(config)
+    if hosts:
+        enabled_hosts = [h for h in enabled_hosts if h.name in hosts]
+
+    results: dict[str, dict[str, dict[str, Any]]] = {}
+
+    for host in enabled_hosts:
+        host_versions = get_remote_versions(host, pypi_names)
+        # Map back to package names
+        results[host.name] = {
+            name_map.get(pypi, pypi): info for pypi, info in host_versions.items()
+        }
+        # Add host metadata
+        results[host.name]["_host"] = {
+            "hostname": host.hostname,
+            "role": host.role,
+            "user": host.user,
+        }
+
+    return results
+
+
+def test_host_connection(host: HostConfig) -> dict[str, Any]:
+    """Test SSH connection to a host.
+
+    Parameters
+    ----------
+    host : HostConfig
+        Host to test.
+
+    Returns
+    -------
+    dict
+        Connection status with keys: connected, error, python_version.
+    """
+    ssh_args = ["ssh"]
+
+    if host.ssh_key:
+        ssh_args.extend(["-i", host.ssh_key])
+
+    if host.port != 22:
+        ssh_args.extend(["-p", str(host.port)])
+
+    ssh_args.extend(
+        [
+            "-o",
+            "BatchMode=yes",
+            "-o",
+            "StrictHostKeyChecking=accept-new",
+            "-o",
+            "ConnectTimeout=5",
+        ]
+    )
+
+    ssh_target = f"{host.user}@{host.hostname}"
+    ssh_args.append(ssh_target)
+    ssh_args.append("python3 --version")
+
+    try:
+        result = subprocess.run(
+            ssh_args,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode == 0:
+            return {
+                "connected": True,
+                "python_version": result.stdout.strip(),
+            }
+        return {
+            "connected": False,
+            "error": result.stderr.strip() or "Connection failed",
+        }
+
+    except subprocess.TimeoutExpired:
+        return {"connected": False, "error": "Connection timed out"}
+    except Exception as e:
+        return {"connected": False, "error": str(e)}
+
+
+# EOF

scitex/_dev/_versions.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-02-02
+# File: scitex/_dev/_versions.py
+
+"""Core version checking logic for the scitex ecosystem."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from ._ecosystem import ECOSYSTEM, get_all_packages, get_local_path
+
+
+def get_version_from_toml(path: Path) -> str | None:
+    """Read version from pyproject.toml."""
+    toml_path = path / "pyproject.toml"
+    if not toml_path.exists():
+        return None
+
+    try:
+        # Python 3.11+
+        import tomllib
+
+        with open(toml_path, "rb") as f:
+            data = tomllib.load(f)
+    except ImportError:
+        try:
+            import tomli
+
+            with open(toml_path, "rb") as f:
+                data = tomli.load(f)
+        except ImportError:
+            # Fallback: regex parse
+            content = toml_path.read_text()
+            match = re.search(
+                r'^version\s*=\s*["\']([^"\']+)["\']', content, re.MULTILINE
+            )
+            return match.group(1) if match else None
+
+    return data.get("project", {}).get("version")
+
+
+def get_version_installed(package: str) -> str | None:
+    """Get version from importlib.metadata."""
+    try:
+        from importlib.metadata import version
+
+        return version(package)
+    except Exception:
+        return None
+
+
+def get_git_latest_tag(path: Path) -> str | None:
+    """Get latest git tag (version tags only)."""
+    if not path.exists():
+        return None
+
+    try:
+        result = subprocess.run(
+            ["git", "describe", "--tags", "--abbrev=0", "--match", "v*"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+
+    # Fallback: list all tags
+    try:
+        result = subprocess.run(
+            ["git", "tag", "-l", "v*", "--sort=-v:refname"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip().split("\n")[0]
+    except Exception:
+        pass
+
+    return None
+
+
+def get_git_branch(path: Path) -> str | None:
+    """Get current git branch."""
+    if not path.exists():
+        return None
+
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+
+    return None
+
+
+def get_pypi_version(package: str) -> str | None:
+    """Fetch latest version from PyPI API."""
+    try:
+        import urllib.request
+
+        url = f"https://pypi.org/pypi/{package}/json"
+        with urllib.request.urlopen(url, timeout=5) as response:
+            import json
+
+            data = json.loads(response.read().decode())
+            return data.get("info", {}).get("version")
+    except Exception:
+        return None
+
+
+def _normalize_version(v: str | None) -> str | None:
+    """Normalize version string (strip v prefix)."""
+    if v is None:
+        return None
+    return v.lstrip("v")
+
+
+def _compare_versions(v1: str | None, v2: str | None) -> int:
+    """Compare two version strings. Returns -1, 0, or 1."""
+    if v1 is None or v2 is None:
+        return 0
+
+    from packaging.version import Version
+
+    try:
+        ver1 = Version(_normalize_version(v1))
+        ver2 = Version(_normalize_version(v2))
+        if ver1 < ver2:
+            return -1
+        if ver1 > ver2:
+            return 1
+        return 0
+    except Exception:
+        # Fallback: string comparison
+        return 0
+
+
+def _determine_status(info: dict[str, Any]) -> tuple[str, list[str]]:
+    """Determine version status and issues."""
+    issues = []
+
+    toml_ver = info.get("local", {}).get("pyproject_toml")
+    installed_ver = info.get("local", {}).get("installed")
+    tag_ver = _normalize_version(info.get("git", {}).get("latest_tag"))
+    pypi_ver = info.get("remote", {}).get("pypi")
+
+    # Check local consistency
+    if toml_ver and installed_ver and toml_ver != installed_ver:
+        issues.append(f"pyproject.toml ({toml_ver}) != installed ({installed_ver})")
+
+    # Check if toml matches tag
+    if toml_ver and tag_ver and toml_ver != tag_ver:
+        issues.append(f"pyproject.toml ({toml_ver}) != git tag ({tag_ver})")
+
+    # Check pypi status
+    if toml_ver and pypi_ver:
+        cmp = _compare_versions(toml_ver, pypi_ver)
+        if cmp > 0:
+            issues.append(f"local ({toml_ver}) > pypi ({pypi_ver}) - ready to release")
+            return "unreleased", issues
+        if cmp < 0:
+            issues.append(f"local ({toml_ver}) < pypi ({pypi_ver}) - outdated")
+            return "outdated", issues
+
+    if issues:
+        return "mismatch", issues
+
+    if not toml_ver:
+        return "unavailable", ["package not found locally"]
+
+    return "ok", []
+
+
+def list_versions(packages: list[str] | None = None) -> dict[str, Any]:
+    """List versions for all ecosystem packages.
+
+    Parameters
+    ----------
+    packages : list[str] | None
+        List of package names to check. If None, checks all ecosystem packages.
+
+    Returns
+    -------
+    dict
+        Version information for each package.
+    """
+    if packages is None:
+        packages = get_all_packages()
+
+    result = {}
+    for pkg in packages:
+        if pkg not in ECOSYSTEM:
+            result[pkg] = {"status": "unknown", "issues": [f"'{pkg}' not in ecosystem"]}
+            continue
+
+        info: dict[str, Any] = {"local": {}, "git": {}, "remote": {}}
+        local_path = get_local_path(pkg)
+        pypi_name = ECOSYSTEM[pkg].get("pypi_name", pkg)
+
+        # Local sources
+        if local_path and local_path.exists():
+            info["local"]["pyproject_toml"] = get_version_from_toml(local_path)
+        info["local"]["installed"] = get_version_installed(pypi_name)
+
+        # Git sources
+        if local_path and local_path.exists():
+            info["git"]["latest_tag"] = get_git_latest_tag(local_path)
+            info["git"]["branch"] = get_git_branch(local_path)
+
+        # Remote sources
+        info["remote"]["pypi"] = get_pypi_version(pypi_name)
+
+        # Determine status
+        status, issues = _determine_status(info)
+        info["status"] = status
+        info["issues"] = issues
+
+        result[pkg] = info
+
+    return result
+
+
+def check_versions(packages: list[str] | None = None) -> dict[str, Any]:
+    """Check version consistency and return detailed status.
+
+    Parameters
+    ----------
+    packages : list[str] | None
+        List of package names to check. If None, checks all ecosystem packages.
+
+    Returns
+    -------
+    dict
+        Detailed version check results with overall summary.
+    """
+    versions = list_versions(packages)
+
+    summary = {
+        "total": len(versions),
+        "ok": 0,
+        "mismatch": 0,
+        "unreleased": 0,
+        "outdated": 0,
+        "unavailable": 0,
+        "unknown": 0,
+    }
+
+    for _pkg, info in versions.items():
+        status = info.get("status", "unknown")
+        if status in summary:
+            summary[status] += 1
+
+    return {"packages": versions, "summary": summary}
+
+
+# EOF

scitex/_mcp_tools/__init__.py

@@ -9,6 +9,7 @@ from .audio import register_audio_tools
 from .canvas import register_canvas_tools
 from .capture import register_capture_tools
 from .dataset import register_dataset_tools
+from .dev import register_dev_tools
 from .diagram import register_diagram_tools
 from .introspect import register_introspect_tools
 from .plt import register_plt_tools
@@ -29,6 +30,7 @@ def register_all_tools(mcp) -> None:
     register_canvas_tools(mcp)
     register_capture_tools(mcp)
     register_dataset_tools(mcp)
+    register_dev_tools(mcp)
     register_diagram_tools(mcp)
     register_introspect_tools(mcp)
     register_plt_tools(mcp)