cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/capabilities/discovery.py

@@ -0,0 +1,207 @@
+"""
+CAT Environment & Capability Discovery per §34, §35, §36, §46, §57, §86.
+Performs real runtime environment inspection.
+Never returns fake capabilities or simulated states.
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import os
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+from .schema import AvailabilityStatus
+
+
+@dataclass
+class EnvironmentSnapshot:
+    """Snapshot of discovered execution targets and software availability."""
+    python_version: str
+    virtual_env: Optional[str]
+    git_installed: bool
+    git_version: str
+    jupyter_installed: bool
+    playwright_installed: bool
+    chromium_installed: bool
+    torch_installed: bool
+    cuda_available: bool
+    gpu_name: str
+    vram_gb: float
+    matlab_available: bool
+    pymol_available: bool
+    chimerax_available: bool
+    blast_available: bool
+    kaggle_configured: bool
+    huggingface_configured: bool
+    github_configured: bool
+    qiskit_installed: bool
+    cirq_installed: bool
+    pennylane_installed: bool
+    discovered_packages: Dict[str, str] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "python_version": self.python_version,
+            "virtual_env": self.virtual_env,
+            "git_installed": self.git_installed,
+            "git_version": self.git_version,
+            "jupyter_installed": self.jupyter_installed,
+            "playwright_installed": self.playwright_installed,
+            "chromium_installed": self.chromium_installed,
+            "torch_installed": self.torch_installed,
+            "cuda_available": self.cuda_available,
+            "gpu_name": self.gpu_name,
+            "vram_gb": self.vram_gb,
+            "matlab_available": self.matlab_available,
+            "pymol_available": self.pymol_available,
+            "chimerax_available": self.chimerax_available,
+            "blast_available": self.blast_available,
+            "kaggle_configured": self.kaggle_configured,
+            "huggingface_configured": self.huggingface_configured,
+            "github_configured": self.github_configured,
+            "qiskit_installed": self.qiskit_installed,
+            "cirq_installed": self.cirq_installed,
+            "pennylane_installed": self.pennylane_installed,
+            "discovered_packages": self.discovered_packages,
+        }
+
+
+def _pkg_version(pkg_name: str) -> Optional[str]:
+    """Return installed package version if present, else None."""
+    try:
+        mod = importlib.import_module(pkg_name)
+        return getattr(mod, "__version__", "installed")
+    except Exception:
+        return None
+
+
+def _has_command(cmd: str) -> bool:
+    """Check if command is on system PATH."""
+    return shutil.which(cmd) is not None
+
+
+def _get_command_output(cmd: List[str], timeout: float = 3.0) -> str:
+    """Execute command and return stdout safely."""
+    try:
+        res = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            timeout=timeout,
+            shell=False,
+        )
+        return res.stdout.strip()
+    except Exception:
+        return ""
+
+
+def discover_environment() -> EnvironmentSnapshot:
+    """Perform real discovery of local runtime tools, libraries, and hardware."""
+    py_ver = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    venv = os.environ.get("VIRTUAL_ENV") or os.environ.get("CONDA_PREFIX")
+
+    # Git
+    git_installed = _has_command("git")
+    git_ver = _get_command_output(["git", "--version"]) if git_installed else ""
+
+    # Jupyter
+    jupyter_installed = _has_command("jupyter") or (_pkg_version("jupyter") is not None) or (_pkg_version("notebook") is not None)
+
+    # Playwright & Chromium
+    playwright_installed = _pkg_version("playwright") is not None
+    chromium_installed = False
+    if playwright_installed:
+        try:
+            from ..browser.engine import PLAYWRIGHT_AVAILABLE
+            chromium_installed = PLAYWRIGHT_AVAILABLE
+        except Exception:
+            chromium_installed = False
+
+    # PyTorch & Accelerators
+    torch_ver = _pkg_version("torch")
+    torch_installed = torch_ver is not None
+    cuda_avail = False
+    gpu_name = ""
+    vram_gb = 0.0
+
+    if torch_installed:
+        try:
+            import torch
+            cuda_avail = torch.cuda.is_available()
+            if cuda_avail:
+                gpu_name = torch.cuda.get_device_name(0)
+                vram_gb = round(torch.cuda.get_device_properties(0).total_memory / (1024**3), 2)
+        except Exception:
+            pass
+
+    if not gpu_name and _has_command("nvidia-smi"):
+        smi = _get_command_output(["nvidia-smi", "--query-gpu=gpu_name,memory.total", "--format=csv,noheader,nounits"])
+        if smi and "," in smi:
+            parts = smi.split(",")
+            gpu_name = parts[0].strip()
+            try:
+                vram_gb = round(float(parts[1].strip()) / 1024.0, 2)
+            except Exception:
+                pass
+
+    # Scientific packages
+    pkgs = {}
+    candidate_pkgs = [
+        "numpy", "scipy", "pandas", "sympy", "matplotlib", "sklearn",
+        "transformers", "biopython", "qiskit", "cirq", "pennylane",
+        "requests", "textual", "rich"
+    ]
+    for p in candidate_pkgs:
+        v = _pkg_version(p)
+        if v:
+            pkgs[p] = v
+
+    # MATLAB
+    matlab_available = _has_command("matlab") or (_pkg_version("matlab") is not None)
+
+    # PyMOL / ChimeraX
+    pymol_available = _has_command("pymol") or os.path.exists(r"C:\Program Files\PyMOL\PyMOLWin.exe") or os.path.exists(r"C:\Program Files (x86)\Schrodinger\PyMOL")
+    chimerax_available = _has_command("chimerax") or os.path.exists(r"C:\Program Files\ChimeraX\bin\ChimeraX.exe")
+
+    # BLAST
+    blast_available = _has_command("blastn") or _has_command("blastp") or (_pkg_version("Bio") is not None)
+
+    # Platforms / Credentials
+    kaggle_path = os.path.expanduser(os.path.join("~", ".kaggle", "kaggle.json"))
+    kaggle_configured = os.path.exists(kaggle_path) or bool(os.environ.get("KAGGLE_USERNAME") and os.environ.get("KAGGLE_KEY"))
+
+    hf_token_path = os.path.expanduser(os.path.join("~", ".cache", "huggingface", "token"))
+    hf_configured = os.path.exists(hf_token_path) or bool(os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN"))
+
+    github_configured = bool(os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN") or _has_command("gh"))
+
+    return EnvironmentSnapshot(
+        python_version=py_ver,
+        virtual_env=venv,
+        git_installed=git_installed,
+        git_version=git_ver,
+        jupyter_installed=jupyter_installed,
+        playwright_installed=playwright_installed,
+        chromium_installed=chromium_installed,
+        torch_installed=torch_installed,
+        cuda_available=cuda_avail,
+        gpu_name=gpu_name,
+        vram_gb=vram_gb,
+        matlab_available=matlab_available,
+        pymol_available=pymol_available,
+        chimerax_available=chimerax_available,
+        blast_available=blast_available,
+        kaggle_configured=kaggle_configured,
+        huggingface_configured=hf_configured,
+        github_configured=github_configured,
+        qiskit_installed="qiskit" in pkgs,
+        cirq_installed="cirq" in pkgs,
+        pennylane_installed="pennylane" in pkgs,
+        discovered_packages=pkgs,
+    )

calc_terminal/capabilities/schema.py

@@ -0,0 +1,221 @@
+"""
+CAT Capability System — Core Schemas and Contracts.
+Defines:
+- AvailabilityStatus: honest capability states per §4, §57, §86
+- CapabilityCategory: functional domain
+- CapabilitySpec: complete capability manifest
+- ExecutionResult / ExecutionError: structured result and error models per §83
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional, Union
+
+
+class AvailabilityStatus(str, Enum):
+    AVAILABLE = "AVAILABLE"
+    UNAVAILABLE = "UNAVAILABLE"
+    AUTHENTICATION_REQUIRED = "AUTHENTICATION_REQUIRED"
+    SOFTWARE_NOT_FOUND = "SOFTWARE_NOT_FOUND"
+    LICENSE_REQUIRED = "LICENSE_REQUIRED"
+    PERMISSION_DENIED = "PERMISSION_DENIED"
+
+
+class CapabilityCategory(str, Enum):
+    FILESYSTEM = "filesystem"
+    TERMINAL = "terminal"
+    PYTHON = "python"
+    BROWSER = "browser"
+    JUPYTER = "jupyter"
+    GIT = "git"
+    ML = "ml"
+    BIO = "bio"
+    SCIENTIFIC = "scientific"
+    PLATFORMS = "platforms"
+    QUANTUM = "quantum"
+    CUSTOM = "custom"
+
+
+@dataclass
+class CapabilitySpec:
+    """Full specification contract for a CAT capability."""
+    name: str
+    version: str
+    category: CapabilityCategory
+    description: str
+    input_schema: Dict[str, Any] = field(default_factory=dict)
+    output_schema: Dict[str, Any] = field(default_factory=dict)
+    error_schema: Dict[str, Any] = field(default_factory=dict)
+    permissions: List[str] = field(default_factory=list)
+    auth_required: bool = False
+    environment_requirements: List[str] = field(default_factory=list)
+    documentation: str = ""
+    tags: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "version": self.version,
+            "category": self.category.value if isinstance(self.category, CapabilityCategory) else str(self.category),
+            "description": self.description,
+            "input_schema": self.input_schema,
+            "output_schema": self.output_schema,
+            "error_schema": self.error_schema,
+            "permissions": self.permissions,
+            "auth_required": self.auth_required,
+            "environment_requirements": self.environment_requirements,
+            "documentation": self.documentation,
+            "tags": self.tags,
+        }
+
+
+class ExecutionError(Exception):
+    """Structured error raised during capability execution per §83."""
+
+    def __init__(
+        self,
+        message: str,
+        tool: str = "",
+        task_id: str = "",
+        retryable: bool = False,
+        error_type: str = "ToolExecutionError",
+        details: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(message)
+        self.message = message
+        self.tool = tool
+        self.task_id = task_id
+        self.retryable = retryable
+        self.error_type = error_type
+        self.details = details or {}
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "type": self.error_type,
+            "tool": self.tool,
+            "task_id": self.task_id,
+            "message": self.message,
+            "retryable": self.retryable,
+            "details": self.details,
+        }
+
+
+@dataclass
+class ExecutionResult:
+    """Standard execution result returned by all capability adapters."""
+    success: bool
+    output: Any = None
+    error: Optional[str] = None
+    status: AvailabilityStatus = AvailabilityStatus.AVAILABLE
+    duration_ms: float = 0.0
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    provenance: Dict[str, Any] = field(default_factory=dict)
+    timestamp: float = field(default_factory=time.time)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "success": self.success,
+            "output": self.output,
+            "error": self.error,
+            "status": self.status.value if isinstance(self.status, AvailabilityStatus) else str(self.status),
+            "duration_ms": self.duration_ms,
+            "metadata": self.metadata,
+            "provenance": self.provenance,
+            "timestamp": self.timestamp,
+        }
+
+
+class Capability:
+    """Callable unit representing a concrete capability implementation."""
+
+    def __init__(
+        self,
+        spec: CapabilitySpec,
+        handler: Callable[[Dict[str, Any], Optional[Dict[str, Any]]], ExecutionResult],
+        health_checker: Optional[Callable[[], Tuple[AvailabilityStatus, str]]] = None,
+    ):
+        self.spec = spec
+        self.handler = handler
+        self.health_checker = health_checker
+        self._last_status: AvailabilityStatus = AvailabilityStatus.AVAILABLE
+        self._last_status_message: str = "Ready"
+        self._last_check_time: float = 0.0
+
+    @property
+    def name(self) -> str:
+        return self.spec.name
+
+    @property
+    def status(self) -> AvailabilityStatus:
+        return self._last_status
+
+    def check_health(self, force: bool = False) -> Tuple[AvailabilityStatus, str]:
+        """Check capability availability and return (status, message)."""
+        now = time.time()
+        if not force and (now - self._last_check_time < 15.0) and self._last_check_time > 0:
+            return self._last_status, self._last_status_message
+
+        if self.health_checker:
+            try:
+                st, msg = self.health_checker()
+                self._last_status = st
+                self._last_status_message = msg
+            except Exception as e:
+                self._last_status = AvailabilityStatus.UNAVAILABLE
+                self._last_status_message = f"Health check failed: {e}"
+        else:
+            self._last_status = AvailabilityStatus.AVAILABLE
+            self._last_status_message = "Ready"
+
+        self._last_check_time = now
+        return self._last_status, self._last_status_message
+
+    def execute(self, args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+        """Run the capability handler with error handling and timing."""
+        t0 = time.perf_counter()
+        # Fast health check if unknown
+        if self._last_check_time == 0:
+            self.check_health()
+
+        if self._last_status in (
+            AvailabilityStatus.SOFTWARE_NOT_FOUND,
+            AvailabilityStatus.AUTHENTICATION_REQUIRED,
+            AvailabilityStatus.LICENSE_REQUIRED,
+            AvailabilityStatus.UNAVAILABLE,
+        ):
+            elapsed = (time.perf_counter() - t0) * 1000.0
+            return ExecutionResult(
+                success=False,
+                error=f"Capability '{self.name}' not available: {self._last_status_message}",
+                status=self._last_status,
+                duration_ms=round(elapsed, 2),
+                metadata={"reason": self._last_status_message},
+            )
+
+        try:
+            res = self.handler(args, context)
+            if not isinstance(res, ExecutionResult):
+                res = ExecutionResult(success=True, output=res)
+            res.duration_ms = round((time.perf_counter() - t0) * 1000.0, 2)
+            return res
+        except ExecutionError as ee:
+            elapsed = (time.perf_counter() - t0) * 1000.0
+            return ExecutionResult(
+                success=False,
+                error=ee.message,
+                status=AvailabilityStatus.UNAVAILABLE,
+                duration_ms=round(elapsed, 2),
+                metadata=ee.to_dict(),
+            )
+        except Exception as e:
+            elapsed = (time.perf_counter() - t0) * 1000.0
+            return ExecutionResult(
+                success=False,
+                error=str(e),
+                status=AvailabilityStatus.UNAVAILABLE,
+                duration_ms=round(elapsed, 2),
+                metadata={"exception": type(e).__name__},
+            )