cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/browser_gui/webview_browser.py

@@ -0,0 +1,57 @@
+"""
+Fallback browser via pywebview (Edge WebView2 on Windows).
+Shows real HTML/CSS/JS, but with minimal chrome when Qt not available.
+Still far better than terminal text — this is a real WebView2 surface.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+def launch_webview_browser(start_url: str = "about:home") -> int:
+    try:
+        import webview  # type: ignore
+    except ImportError:
+        print("[CAT Browser] pywebview not installed. Run: pip install pywebview", file=sys.stderr)
+        return 2
+
+    # Normalize about:home to a data URL with new-tab HTML
+    if start_url in ("about:home", "about:blank", "", None):
+        # Load new-tab HTML via data URL
+        try:
+            from .qt_browser import _new_tab_html  # reuse same HTML
+            html = _new_tab_html()
+            # pywebview can load html string via data URL
+            import urllib.parse
+            data_url = "data:text/html;charset=utf-8," + urllib.parse.quote(html)
+            start_url = data_url
+        except Exception:
+            start_url = "https://www.google.com"
+
+    # Ensure localhost URLs are correct
+    if start_url.startswith("localhost:"):
+        start_url = "http://" + start_url
+
+    title = "CAT Browser"
+    # Try to get Fomoji title if start_url is fomoji
+    if "localhost:3000" in start_url:
+        title = "CAT Browser — Fomoji"
+
+    try:
+        # Create window with reasonable size, resizable, with min size
+        window = webview.create_window(
+            title, start_url,
+            width=1200, height=800,
+            min_size=(900, 600),
+            text_select=True,
+        )
+        # Start the GUI loop (blocks until closed)
+        # On Windows, this uses WebView2 and will render JS/WebGL correctly
+        webview.start(debug=False)
+        return 0
+    except Exception as e:
+        print(f"[CAT Browser] webview failed: {e}", file=sys.stderr)
+        # Fallback: try to open in OS default browser as last resort? But spec says no external.
+        # Instead, show error.
+        return 1

calc_terminal/capabilities/__init__.py

@@ -0,0 +1,35 @@
+"""
+CAT Capabilities Package per §4, §56, §57:
+Central Capability Bus, schema definitions, environment discovery, and adapters.
+"""
+
+from .schema import (
+    AvailabilityStatus,
+    Capability,
+    CapabilityCategory,
+    CapabilitySpec,
+    ExecutionError,
+    ExecutionResult,
+)
+from .bus import CapabilityBus, capability_bus
+from .discovery import EnvironmentSnapshot, discover_environment
+from .adapters import register_all_adapters
+
+# Auto-register all built-in adapters into the singleton bus
+if not capability_bus._initialized:
+    register_all_adapters(capability_bus)
+    capability_bus._initialized = True
+
+__all__ = [
+    "AvailabilityStatus",
+    "CapabilityCategory",
+    "CapabilitySpec",
+    "ExecutionError",
+    "ExecutionResult",
+    "Capability",
+    "CapabilityBus",
+    "capability_bus",
+    "EnvironmentSnapshot",
+    "discover_environment",
+    "register_all_adapters",
+]

calc_terminal/capabilities/adapters/__init__.py

@@ -0,0 +1,33 @@
+"""
+CAT Capability Adapters package.
+Exposes concrete handlers registered into capability_bus.
+"""
+
+from .filesystem import register_filesystem_capabilities
+from .terminal import register_terminal_capabilities
+from .python_exec import register_python_capabilities
+from .git_adapter import register_git_capabilities
+from .browser_adapter import register_browser_capabilities
+from .jupyter_adapter import register_jupyter_capabilities
+from .ml_frameworks import register_ml_capabilities
+from .bioinformatics import register_bio_capabilities
+from .structural_bio import register_structural_bio_capabilities
+from .scientific_comp import register_scientific_capabilities
+from .platforms import register_platform_capabilities
+from .quantum_adapter import register_quantum_capabilities
+
+
+def register_all_adapters(bus):
+    """Register all built-in capabilities into the given CapabilityBus."""
+    register_filesystem_capabilities(bus)
+    register_terminal_capabilities(bus)
+    register_python_capabilities(bus)
+    register_git_capabilities(bus)
+    register_browser_capabilities(bus)
+    register_jupyter_capabilities(bus)
+    register_ml_capabilities(bus)
+    register_bio_capabilities(bus)
+    register_structural_bio_capabilities(bus)
+    register_scientific_capabilities(bus)
+    register_platform_capabilities(bus)
+    register_quantum_capabilities(bus)

calc_terminal/capabilities/adapters/bioinformatics.py

@@ -0,0 +1,204 @@
+"""
+Bioinformatics & Genomics Capability Adapter per §45:
+- blast.search
+- ncbi.query
+- biopython.parse
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import urllib.request
+import urllib.parse
+import json
+from typing import Any, Dict, Optional, Tuple
+
+from ..schema import (
+    AvailabilityStatus,
+    Capability,
+    CapabilityCategory,
+    CapabilitySpec,
+    ExecutionResult,
+)
+
+
+def _check_bio_health() -> Tuple[AvailabilityStatus, str]:
+    has_local = shutil.which("blastn") is not None or shutil.which("blastp") is not None
+    try:
+        import Bio  # noqa: F401
+        has_biopython = True
+    except ImportError:
+        has_biopython = False
+
+    if has_local or has_biopython:
+        return AvailabilityStatus.AVAILABLE, f"Bioinformatics ready (local BLAST: {has_local}, Biopython: {has_biopython})"
+    return AvailabilityStatus.AVAILABLE, "NCBI REST API available (local BLAST/Biopython not installed)"
+
+
+def _blast_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    sequence = args.get("sequence", "")
+    program = args.get("program", "blastp")  # blastp, blastn
+    database = args.get("database", "nr")
+
+    if not sequence:
+        return ExecutionResult(success=False, error="sequence argument is required (FASTA or raw sequence)")
+
+    # Check for local blast tool
+    if shutil.which(program):
+        try:
+            proc = subprocess.run(
+                [program, "-db", database, "-outfmt", "0"],
+                input=sequence,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                timeout=60.0,
+            )
+            if proc.returncode == 0:
+                return ExecutionResult(
+                    success=True,
+                    output=proc.stdout,
+                    metadata={"engine": "local", "program": program, "database": database},
+                )
+        except Exception:
+            pass
+
+    # Fallback to NCBI Web API
+    try:
+        url = "https://blast.ncbi.nlm.nih.gov/Blast.cgi"
+        data = urllib.parse.urlencode({
+            "CMD": "Put",
+            "PROGRAM": program,
+            "DATABASE": database,
+            "QUERY": sequence,
+        }).encode("utf-8")
+        req = urllib.request.Request(url, data=data, headers={"User-Agent": "CAT-AI-Platform/1.0"})
+        with urllib.request.urlopen(req, timeout=10.0) as resp:
+            body = resp.read().decode("utf-8", errors="replace")
+        # Extract RID (Request ID)
+        rid = ""
+        for line in body.splitlines():
+            if "RID =" in line:
+                rid = line.split("RID =")[1].strip()
+                break
+
+        return ExecutionResult(
+            success=True,
+            output=f"BLAST job submitted to NCBI. Request ID (RID): {rid or 'pending'}",
+            metadata={"engine": "ncbi_rest", "rid": rid, "program": program, "database": database},
+        )
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"BLAST query failed: {e}")
+
+
+def _ncbi_query_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    term = args.get("term", "")
+    db = args.get("db", "protein")
+    if not term:
+        return ExecutionResult(success=False, error="term argument is required")
+
+    try:
+        url = f"https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db={db}&term={urllib.parse.quote_plus(term)}&retmode=json&retmax=10"
+        req = urllib.request.Request(url, headers={"User-Agent": "CAT-AI-Platform/1.0"})
+        with urllib.request.urlopen(req, timeout=8.0) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+        id_list = data.get("esearchresult", {}).get("idlist", [])
+        return ExecutionResult(
+            success=True,
+            output=id_list,
+            metadata={"db": db, "count": len(id_list), "ids": id_list},
+        )
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"NCBI query failed: {e}")
+
+
+def _biopython_parse_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    file_path = args.get("path", "")
+    fmt = args.get("format", "fasta")
+    if not file_path:
+        return ExecutionResult(success=False, error="path argument is required")
+    file_path = os.path.abspath(os.path.expanduser(file_path))
+    if not os.path.exists(file_path):
+        return ExecutionResult(success=False, error=f"File not found: {file_path}")
+
+    try:
+        from Bio import SeqIO
+        records = []
+        for rec in SeqIO.parse(file_path, fmt):
+            records.append({
+                "id": rec.id,
+                "name": rec.name,
+                "description": rec.description,
+                "length": len(rec.seq),
+                "sequence": str(rec.seq)[:100] + ("..." if len(rec.seq) > 100 else ""),
+            })
+        return ExecutionResult(success=True, output=records, metadata={"count": len(records)})
+    except ImportError:
+        # Simple fallback parser for FASTA if biopython not installed
+        if fmt.lower() == "fasta":
+            records = []
+            with open(file_path, "r", encoding="utf-8") as f:
+                cur_id = ""
+                cur_seq = []
+                for line in f:
+                    line = line.strip()
+                    if line.startswith(">"):
+                        if cur_id:
+                            records.append({"id": cur_id, "length": sum(len(s) for s in cur_seq)})
+                        cur_id = line[1:]
+                        cur_seq = []
+                    else:
+                        cur_seq.append(line)
+                if cur_id:
+                    records.append({"id": cur_id, "length": sum(len(s) for s in cur_seq)})
+            return ExecutionResult(success=True, output=records, metadata={"count": len(records), "parser": "fallback"})
+        return ExecutionResult(success=False, error="Biopython is required for this format (run: pip install biopython)", status=AvailabilityStatus.SOFTWARE_NOT_FOUND)
+
+
+def register_bio_capabilities(bus):
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="blast.search",
+            version="1.0.0",
+            category=CapabilityCategory.BIO,
+            description="Run BLAST sequence similarity search via local BLAST+ or NCBI REST service.",
+            input_schema={"sequence": "string", "program": "string?", "database": "string?"},
+            output_schema={"output": "string"},
+            permissions=["read_workspace"],
+            documentation="Executes nucleotide or protein sequence alignment.",
+        ),
+        handler=_blast_handler,
+        health_checker=_check_bio_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="ncbi.query",
+            version="1.0.0",
+            category=CapabilityCategory.BIO,
+            description="Query NCBI Entrez database for proteins, nucleotides or PubMed identifiers.",
+            input_schema={"term": "string", "db": "string?"},
+            output_schema={"ids": "list"},
+            permissions=["read_workspace"],
+            documentation="Queries NCBI E-utilities.",
+        ),
+        handler=_ncbi_query_handler,
+        health_checker=_check_bio_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="biopython.parse",
+            version="1.0.0",
+            category=CapabilityCategory.BIO,
+            description="Parse biological sequence files (FASTA, GenBank, PDB).",
+            input_schema={"path": "string", "format": "string?"},
+            output_schema={"records": "list"},
+            permissions=["read_workspace"],
+            documentation="Extracts biological sequence records from files.",
+        ),
+        handler=_biopython_parse_handler,
+        health_checker=_check_bio_health,
+    ))

calc_terminal/capabilities/adapters/browser_adapter.py

@@ -0,0 +1,205 @@
+"""
+Browser Capabilities Adapter per §68:
+- browser.navigate
+- browser.click
+- browser.type
+- browser.screenshot
+- browser.inspect
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, Optional, Tuple
+
+from ..schema import (
+    AvailabilityStatus,
+    Capability,
+    CapabilityCategory,
+    CapabilitySpec,
+    ExecutionResult,
+)
+
+
+def _check_browser_health() -> Tuple[AvailabilityStatus, str]:
+    try:
+        from ...browser.engine import PLAYWRIGHT_AVAILABLE
+        if PLAYWRIGHT_AVAILABLE:
+            return AvailabilityStatus.AVAILABLE, "Playwright Chromium engine available"
+        return AvailabilityStatus.SOFTWARE_NOT_FOUND, "playwright package not installed (run: pip install playwright && playwright install chromium)"
+    except Exception as e:
+        return AvailabilityStatus.UNAVAILABLE, str(e)
+
+
+def _navigate_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    url = args.get("url", "")
+    if not url:
+        return ExecutionResult(success=False, error="url argument is required")
+
+    try:
+        from ...browser.preview import PreviewController
+        ctrl = PreviewController.instance() if hasattr(PreviewController, "instance") else None
+        if ctrl and ctrl.running:
+            res = ctrl.navigate(url)
+            return ExecutionResult(success=True, output=f"Navigated to {url}", metadata={"url": url})
+        # If preview controller not actively running, check standalone Playwright
+        from ...browser.engine import BrowserEngine
+        engine = BrowserEngine(headless=True)
+        engine.start()
+        snap = engine.navigate(url)
+        engine.stop()
+        return ExecutionResult(
+            success=True,
+            output=f"Successfully loaded {snap.url} (HTTP {snap.status_code}) - Title: '{snap.title}'",
+            metadata={"title": snap.title, "url": snap.url, "status_code": snap.status_code},
+        )
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"Navigation failed: {e}")
+
+
+def _click_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    target = args.get("target") or args.get("selector", "")
+    if not target:
+        return ExecutionResult(success=False, error="target or selector argument is required")
+
+    try:
+        from ...browser.preview import PreviewController
+        ctrl = PreviewController.instance() if hasattr(PreviewController, "instance") else None
+        if ctrl and ctrl.engine and ctrl.engine.available:
+            ok = ctrl.engine.click(target)
+            return ExecutionResult(success=ok, output=f"Clicked element '{target}'" if ok else f"Could not find element '{target}'")
+        return ExecutionResult(success=False, error="Browser engine is not currently running")
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"Browser click failed: {e}")
+
+
+def _type_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    target = args.get("target") or args.get("selector", "")
+    text = args.get("text", "")
+    if not target:
+        return ExecutionResult(success=False, error="target argument is required")
+
+    try:
+        from ...browser.preview import PreviewController
+        ctrl = PreviewController.instance() if hasattr(PreviewController, "instance") else None
+        if ctrl and ctrl.engine and ctrl.engine.available:
+            ok = ctrl.engine.type_text(target, text)
+            return ExecutionResult(success=ok, output=f"Typed text into '{target}'" if ok else f"Could not type into '{target}'")
+        return ExecutionResult(success=False, error="Browser engine is not currently running")
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"Browser type failed: {e}")
+
+
+def _screenshot_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    dest = args.get("destination", "screenshot.png")
+    dest = os.path.abspath(os.path.expanduser(dest))
+    try:
+        from ...browser.preview import PreviewController
+        ctrl = PreviewController.instance() if hasattr(PreviewController, "instance") else None
+        if ctrl and ctrl.engine and ctrl.engine.available:
+            snap_path = ctrl.engine.screenshot(dest)
+            return ExecutionResult(success=True, output=f"Screenshot saved to {dest}", metadata={"path": dest})
+        return ExecutionResult(success=False, error="Browser engine is not running to take screenshot")
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"Screenshot failed: {e}")
+
+
+def _inspect_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    try:
+        from ...browser.preview import PreviewController
+        ctrl = PreviewController.instance() if hasattr(PreviewController, "instance") else None
+        if ctrl and ctrl.engine and ctrl.engine.available:
+            snap = ctrl.engine.snapshot()
+            return ExecutionResult(
+                success=True,
+                output={
+                    "title": snap.title,
+                    "url": snap.url,
+                    "status_code": snap.status_code,
+                    "headings": snap.headings,
+                    "links_count": len(snap.links),
+                    "buttons_count": len(snap.buttons),
+                    "console_errors": snap.js_errors,
+                },
+                metadata={"title": snap.title, "url": snap.url},
+            )
+        return ExecutionResult(success=False, error="Browser engine is not currently running")
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"Inspect failed: {e}")
+
+
+def register_browser_capabilities(bus):
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="browser.navigate",
+            version="1.0.0",
+            category=CapabilityCategory.BROWSER,
+            description="Navigate to a URL using the real embedded Chromium engine.",
+            input_schema={"url": "string"},
+            output_schema={"output": "string"},
+            permissions=["browser_automation"],
+            documentation="Loads a webpage in Chromium and waits for network idle.",
+        ),
+        handler=_navigate_handler,
+        health_checker=_check_browser_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="browser.click",
+            version="1.0.0",
+            category=CapabilityCategory.BROWSER,
+            description="Click on an interactive element by selector or visible text.",
+            input_schema={"target": "string"},
+            output_schema={"output": "string"},
+            permissions=["browser_automation"],
+            documentation="Clicks an element in the active browser page.",
+        ),
+        handler=_click_handler,
+        health_checker=_check_browser_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="browser.type",
+            version="1.0.0",
+            category=CapabilityCategory.BROWSER,
+            description="Type text into an input field in the active browser page.",
+            input_schema={"target": "string", "text": "string"},
+            output_schema={"output": "string"},
+            permissions=["browser_automation"],
+            documentation="Focuses and types into an input/textarea.",
+        ),
+        handler=_type_handler,
+        health_checker=_check_browser_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="browser.screenshot",
+            version="1.0.0",
+            category=CapabilityCategory.BROWSER,
+            description="Capture a screenshot of the current browser page to disk.",
+            input_schema={"destination": "string?"},
+            output_schema={"output": "string"},
+            permissions=["browser_automation"],
+            documentation="Saves a PNG screenshot of the viewport.",
+        ),
+        handler=_screenshot_handler,
+        health_checker=_check_browser_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="browser.inspect",
+            version="1.0.0",
+            category=CapabilityCategory.BROWSER,
+            description="Inspect the current page DOM structure, interactive elements, and console errors.",
+            input_schema={},
+            output_schema={"output": "object"},
+            permissions=["browser_automation"],
+            documentation="Extracts headings, links, buttons, and console output.",
+        ),
+        handler=_inspect_handler,
+        health_checker=_check_browser_health,
+    ))