cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/commands_data.py

@@ -0,0 +1,139 @@
+"""
+CCT slash-command registry — single source of truth.
+
+This used to be a module-level list inside app.py. It moved here in
+v0.6.0 so calc_terminal/ui/palette.py's CommandPalette (the "/ opens an
+integrated command palette inside the composer" piece of the v6.0
+redesign brief) can list/filter the *exact* same commands the plain
+print()/input() REPL supports, instead of hand-maintaining a second
+copy that silently drifts out of sync every time a command is added.
+
+app.py imports COMMANDS from here (see the top of app.py) and behaves
+exactly as it did before this refactor — nothing about the REPL's
+behavior changed, only where the list lives.
+"""
+
+COMMANDS = [
+    ("/help", "Show help & shortcuts"),
+    ("/calculator", "Quick scientific calculator"),
+    ("/solve", "Universal formula calculator (39 formulas + custom)"),
+    ("/formulas", "Browse the formula library"),
+    ("/kinetics", "Chemical kinetics numericals"),
+    ("/derive", "Real step-by-step calculus derivations (not examples)"),
+    ("/electrochemistry", "Cell potential & Nernst numericals"),
+    ("/atomsim", "Live Bohr atom & electron simulation"),
+    ("/orbitals", "Live quantum orbital (electron cloud) simulation"),
+    ("/orbitalgrid", "Export a reference chart of many hydrogen orbitals"),
+    ("/bonding", "Chemical bonding density map (ELF-style) for a molecule"),
+    ("/bloch", "Bloch sphere for a single qubit state (theta, phi in degrees)"),
+    ("/permissions", "View or switch AI permission mode (ask/restricted/full)"),
+    ("/workspace", "Workspace manager — detect, open, and manage project folders; browse generated files"),
+    ("/graph", "Chemistry graphs — animated 2D + exported 2D/3D"),
+    ("/game", "Element Quiz — learn chemistry by playing"),
+    ("/history", "Review previously solved notebooks"),
+    ("/settings", "Autosave, precision & preferences"),
+    ("/shortcuts", "Full shortcut key reference"),
+    ("/about", "About this terminal"),
+    ("/random", "Solve a random numerical"),
+    ("/upload", "Simulate solving from an image"),
+    ("/voice", "Simulate voice input"),
+    ("/sim3d", "[BETA] Real-time 3D Atomic Simulation"),
+    ("/gpu3d", "[BETA] Real GPU-rendered 3D (atom/graph/scale) — opens in browser"),
+    ("/mode", "Cycle or jump to an AI mode: Notebook, Research, Plan, Build, Debugger, or Agent"),
+    ("/summarize", "Summarize the full conversation and generate a smart chat title"),
+    ("/summary", "Alias for /summarize — full chat summary & title"),
+    ("/notebook", "Switch to Notebook AI mode — chemistry/physics/math, daily use"),
+    ("/research", "Deep research: multi-query web search + AI-synthesized summary"),
+    ("/agent", "Switch to Agent AI mode — real tool use: solves/plots/simulates for you"),
+    ("/build", "Switch to Build AI mode — code generation, debugging, architecture"),
+    ("/plan", "Switch to Plan AI mode — roadmaps, brainstorming, prototypes"),
+    ("/debug", "Switch to Debugger AI mode — focused troubleshooting of broken code"),
+    ("/ai", "Alias for /notebook — CAT AI's original quick-chat persona"),
+    ("/install", "Autonomous package manager — install real packages with permission"),
+    ("/packages", "Installation dashboard — supported managers & remembered decisions"),
+    ("/pipeline", "AI Execution Pipeline — Planner→Research→Build→Verify, fully visible"),
+    ("/orchestrate", "Agent Orchestrator — Coordinator + specialist agent roster"),
+    ("/devices", "Responsible device control — provider roster & approval-gated actions"),
+    ("/ai-verify", "Test your AI provider connection & list models"),
+    ("/memory", "What CAT remembers about you — facts, activity, topics"),
+    ("/codepad", "Write/run code, or have CAT AI generate it (GitHub Light syntax)"),
+    ("/edit", "Plain-text in-terminal editor — notes, todo lists, snippets"),
+    ("/model", "Switch AI model for the current provider (live list, search & filters)"),
+    ("/model search", "Search available models by name, family, or capability"),
+    ("/model refresh", "Force-refresh the model list from the provider's API"),
+    ("/free", "Show only free models for the current provider"),
+    ("/latest", "Show the newest available models for the current provider"),
+    ("/provider", "Switch AI provider (data-driven list from providers.json)"),
+    ("/status", "Provider / model / source / last refresh status"),
+    ("/refresh-models", "Force-refresh the model list from the selected provider"),
+    ("/tokens", "Session token usage & estimated context remaining"),
+    ("/theme", "Switch terminal theme — Tokyo Night (dark) or GitHub Light"),
+    ("/websearch", "Live web search (no API key needed)"),
+    ("/import", "Import a text file, image, or .zip for the AI/agent to read/see"),
+    ("/pet", "Show the live mascot pet — walks, runs, or sleeps based on activity"),
+    ("/react", "NEW Reaction simulator — balance equations + kinetics/equilibrium playback"),
+    ("/export", "NEW Export solved notebooks to Markdown or PDF"),
+    ("/tui", "NEW Real Textual dashboard — sidebar + scrolling history + status bar"),
+    ("/composer", "Reopen the primary chat UI if you dropped to the fallback terminal"),
+    ("/open", "Open a project folder as the IDE workspace (Explorer + Editor)"),
+    ("/sidebar", "Toggle the Explorer sidebar"),
+    ("/find", "Toggle find/replace in the active editor tab"),
+    ("/preview", "Live Web Preview — open/close the embedded browser (Ctrl+Shift+P)"),
+    ("/preview start", "Start the live preview server + embedded browser"),
+    ("/preview stop", "Stop the live preview and return to the code editor"),
+    ("/preview reload", "Reload the web preview page"),
+    ("/preview fullscreen", "Expand/restore the right workspace pane (⿻)"),
+    ("/preview status", "Show live server / browser / watcher state"),
+    ("/browser", "CAT Browser — graphical browser (tabs, address bar, Fomoji)"),
+    ("/browse", "Alias for /browser — open any URL or search"),
+    ("/cat", "Open CAT Browser (Chromium / Qt WebEngine) — our own browser"),
+    ("/browser open", "Open a URL in CAT Browser"),
+    ("/browser search", "Search the web in CAT Browser (Google/DuckDuckGo)"),
+    ("/signout", "Sign out of Fomoji — clear CAT session"),
+    ("/logout", "Alias for /signout"),
+    ("/todo", "NEW AI Todo Manager — manual + AI-detected tasks, per project"),
+    ("/timeline", "NEW Session Timeline — searchable log of this run's activity"),
+    ("/copycode", "Copy the most recent code block shown by the AI to your clipboard"),
+    ("/vision", "CAT Vision — screen sharing + annotation + visual debugging"),
+    ("/vision start", "Start a Vision capture session"),
+    ("/vision stop", "Stop the current Vision session"),
+    ("/vision pause", "Pause Vision capture"),
+    ("/vision analyze", "Analyze current annotated region"),
+    ("/vision screenshot", "Capture a single screenshot for analysis"),
+    ("/vision clear", "Clear Vision session data"),
+    ("/touch", "Toggle touch-friendly touchscreen laptop UI mode"),
+    ("/cat doctor", "Comprehensive 19-dimension health check across runtime, providers & tools"),
+    ("/cat self-test", "Automated self-test suite validating all core agent subsystems"),
+    ("/cat verify", "Verify workspace edits, AST syntax, tests, and endpoints via Reality Engine"),
+    ("/doctor", "Alias for /cat doctor — system diagnostic check"),
+    ("/self-test", "Alias for /cat self-test — automated test suite"),
+    ("/verify", "Alias for /cat verify — reality engine verification"),
+    ("/mode create", "Create a custom AI mode by name"),
+    ("/mode list", "List active built-in and custom AI modes"),
+    ("/mode delete", "Delete a custom AI mode"),
+    ("/checkpoint", "Create workspace snapshot or rollback recent changes"),
+    ("/compute", "List compute fabric targets and hardware resources"),
+    ("/fabric", "Alias for /compute — inspect compute fabric"),
+    ("/clear", "Clear screen & return home"),
+    ("/exit", "Quit Chemistry Calc Terminal"),
+]
+
+# Commands calc_terminal/ui/app.py's CCTApp runs natively, in-process,
+# without leaving the Textual UI — small, quick, no blocking input()
+# menus of their own. Every other command in COMMANDS above still
+# works from inside the composer: CCTApp suspends the Textual screen
+# (textual's real suspend/resume, not a fake), lets the existing
+# fallback_cli.App.handle() run it exactly as it always has in a real
+# terminal, and resumes the chat UI when that finishes — so nothing on
+# this list is unsupported, this is just the set worth a native,
+# no-suspend round trip.
+NATIVE_UI_COMMANDS = {"/clear", "/theme", "/model", "/tokens", "/tui", "/composer",
+                       "/history", "/memory", "/about", "/help", "/exit",
+                       "/mode", "/notebook", "/agent", "/build", "/plan", "/ai",
+                       "/research", "/debug",
+                       "/open", "/sidebar", "/find", "/todo", "/timeline",
+                       "/preview", "/browser", "/browse", "/cat",
+                       "/vision", "/signout", "/logout", "/touch",
+                       "/doctor", "/self-test", "/verify", "/checkpoint",
+                       "/compute", "/fabric"}
+

calc_terminal/compatibility_engine.py

@@ -0,0 +1,352 @@
+"""
+calc_terminal/compatibility_engine.py
+=====================================
+CAT Model Compatibility Engine — Intelligent hardware-to-model matching.
+
+Part of CAT (Created by Kazi Zillani).
+Calculates realistic operational memory footprints considering:
+  - Parameter count (e.g. 1.5B, 3B, 4B, 7B, 14B, 32B, 70B)
+  - Quantization format (e.g. Q4_K_M, Q5_K_M, Q8_0, FP16, FP8)
+  - Model disk size
+  - Target context window (e.g. 4K, 8K, 32K, 128K)
+  - KV-cache memory requirements
+  - GPU VRAM vs. System RAM hybrid offloading
+  - Available memory headroom
+
+Classifies models into the 5 standard CAT tiers:
+  🟢 Excellent       — 100% in VRAM, full GPU acceleration, peak tokens/sec.
+  🟢 Recommended     — Fully comfortable on device, fast interactive speeds.
+  🟡 Usable          — Supported via RAM/CPU offloading; acceptable speed.
+  🟠 Heavy           — High RAM consumption; reduced generation speed.
+  🔴 Not Recommended — Exceeds total system resources, high risk of OOM.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional, Tuple
+
+from .hardware_analyzer import HardwareAnalyzer, HardwareProfile
+
+
+@dataclass
+class CompatibilityReport:
+    model_name: str
+    tier: str              # EXCELLENT, RECOMMENDED, USABLE, HEAVY, NOT_RECOMMENDED
+    tier_label: str        # e.g. "🟢 Excellent", "🟢 Recommended", etc.
+    tier_label_ascii: str  # e.g. "[EXCELLENT]", "[RECOMMENDED]", etc.
+    weights_gb: float
+    kv_cache_gb: float
+    total_memory_gb: float
+    vram_used_gb: float
+    ram_offload_gb: float
+    estimated_tps: float   # Estimated tokens per second
+    summary: str
+    details: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "model_name": self.model_name,
+            "tier": self.tier,
+            "tier_label": self.tier_label,
+            "tier_label_ascii": self.tier_label_ascii,
+            "weights_gb": self.weights_gb,
+            "kv_cache_gb": self.kv_cache_gb,
+            "total_memory_gb": self.total_memory_gb,
+            "vram_used_gb": self.vram_used_gb,
+            "ram_offload_gb": self.ram_offload_gb,
+            "estimated_tps": self.estimated_tps,
+            "summary": self.summary,
+            "details": self.details,
+        }
+
+
+class ModelCompatibilityEngine:
+    """Evaluates how a model will perform on the user's specific hardware."""
+
+    TIER_EXCELLENT = "EXCELLENT"
+    TIER_RECOMMENDED = "RECOMMENDED"
+    TIER_USABLE = "USABLE"
+    TIER_HEAVY = "HEAVY"
+    TIER_NOT_RECOMMENDED = "NOT_RECOMMENDED"
+
+    TIER_BADGES = {
+        "EXCELLENT": "🟢 Excellent",
+        "RECOMMENDED": "🟢 Recommended",
+        "USABLE": "🟡 Usable",
+        "HEAVY": "🟠 Heavy",
+        "NOT_RECOMMENDED": "🔴 Not Recommended",
+    }
+
+    TIER_ASCII_BADGES = {
+        "EXCELLENT": "[EXCELLENT]",
+        "RECOMMENDED": "[RECOMMENDED]",
+        "USABLE": "[USABLE]",
+        "HEAVY": "[HEAVY]",
+        "NOT_RECOMMENDED": "[NOT RECOMMENDED]",
+    }
+
+    @classmethod
+    def evaluate_model(
+        cls,
+        model_name: str,
+        params_str: str = "",
+        size_gb: float = 0.0,
+        quant: str = "Q4_K_M",
+        context_len: int = 4096,
+        hardware: Optional[HardwareProfile] = None,
+    ) -> CompatibilityReport:
+        """Calculate complete compatibility profile for a model."""
+        hw = hardware or HardwareAnalyzer.analyze()
+
+        # 1. Parse parameter count in billions
+        billions = cls._parse_params(params_str or model_name)
+
+        # 2. Calculate base weights memory
+        if size_gb > 0.1:
+            weights_gb = round(size_gb, 2)
+        else:
+            weights_gb = round(cls._estimate_weights_gb(billions, quant), 2)
+
+        # 3. Calculate KV-cache memory requirement
+        kv_cache_gb = round(cls._estimate_kv_cache_gb(billions, context_len), 2)
+
+        # Runtime overhead (CUDA buffers, context allocation) ~0.5 GB
+        runtime_overhead = 0.5
+        total_memory_gb = round(weights_gb + kv_cache_gb + runtime_overhead, 2)
+
+        # 4. Compare with GPU VRAM and System RAM
+        vram_total = hw.gpu.vram_total_gb if hw.gpu.detected else 0.0
+        vram_available = hw.gpu.vram_free_gb if hw.gpu.detected else 0.0
+        if vram_available <= 0:
+            vram_available = vram_total * 0.85
+
+        ram_total = hw.ram.total_gb
+        ram_available = hw.ram.available_gb
+
+        # Compute offload split
+        if hw.gpu.detected and vram_total > 0.5:
+            if total_memory_gb <= vram_available:
+                vram_used = total_memory_gb
+                ram_offload = 0.0
+            else:
+                vram_used = max(0.0, vram_available - 0.5)
+                ram_offload = max(0.0, total_memory_gb - vram_used)
+        else:
+            vram_used = 0.0
+            ram_offload = total_memory_gb
+
+        # 5. Classify into Tiers
+        tier, summary, details, est_tps = cls._classify_tier(
+            hw=hw,
+            billions=billions,
+            weights_gb=weights_gb,
+            total_memory_gb=total_memory_gb,
+            vram_used=vram_used,
+            ram_offload=ram_offload,
+            vram_total=vram_total,
+            ram_total=ram_total,
+            context_len=context_len,
+        )
+
+        badge = cls.TIER_BADGES.get(tier, "🟡 Usable")
+        badge_ascii = cls.TIER_ASCII_BADGES.get(tier, "[USABLE]")
+
+        return CompatibilityReport(
+            model_name=model_name,
+            tier=tier,
+            tier_label=badge,
+            tier_label_ascii=badge_ascii,
+            weights_gb=weights_gb,
+            kv_cache_gb=kv_cache_gb,
+            total_memory_gb=total_memory_gb,
+            vram_used_gb=round(vram_used, 2),
+            ram_offload_gb=round(ram_offload, 2),
+            estimated_tps=est_tps,
+            summary=summary,
+            details=details,
+        )
+
+    @classmethod
+    def _parse_params(cls, text: str) -> float:
+        """Extract billion parameters from string like '70b', '3.8B', 'qwen2.5-coder:3b'."""
+        text = text.lower()
+        match = re.search(r"[:\-_]?(\d+(?:\.\d+)?)\s*b\b", text)
+        if match:
+            try:
+                return float(match.group(1))
+            except Exception:
+                pass
+        match_m = re.search(r"[:\-_]?(\d+(?:\.\d+)?)\s*m\b", text)
+        if match_m:
+            try:
+                return float(match_m.group(1)) / 1000.0
+            except Exception:
+                pass
+        # Default fallback
+        return 7.0
+
+    @classmethod
+    def _estimate_weights_gb(cls, billions: float, quant: str) -> float:
+        """Estimate model weights size based on parameter count and quantization."""
+        q = quant.upper()
+        if "Q2" in q:
+            bits = 2.6
+        elif "Q3" in q:
+            bits = 3.5
+        elif "Q4" in q:
+            bits = 4.5
+        elif "Q5" in q:
+            bits = 5.5
+        elif "Q6" in q:
+            bits = 6.6
+        elif "Q8" in q or "FP8" in q:
+            bits = 8.5
+        elif "16" in q or "FP16" in q:
+            bits = 16.0
+        else:
+            bits = 4.5  # Q4_K_M default
+
+        return max(0.4, (billions * bits) / 8.0)
+
+    @classmethod
+    def _estimate_kv_cache_gb(cls, billions: float, context_len: int) -> float:
+        """Estimate KV cache memory consumption for target context."""
+        # Baseline: ~0.25MB per 1K context for ~7B models, scales with params and context
+        heads_dim_factor = max(0.5, (billions / 7.0) ** 0.5)
+        mb = (context_len / 1024.0) * 0.25 * heads_dim_factor * 1024.0
+        return mb / 1024.0
+
+    @classmethod
+    def _classify_tier(
+        cls,
+        hw: HardwareProfile,
+        billions: float,
+        weights_gb: float,
+        total_memory_gb: float,
+        vram_used: float,
+        ram_offload: float,
+        vram_total: float,
+        ram_total: float,
+        context_len: int,
+    ) -> Tuple[str, str, list[str], float]:
+        details = []
+        details.append(f"Model parameters: {billions:.1f}B | Operational Memory: {total_memory_gb:.1f} GB")
+
+        total_system_memory = (vram_total if hw.gpu.detected else 0) + ram_total
+
+        # Impossible / Out of Memory
+        if total_memory_gb > (total_system_memory * 0.95):
+            tier = cls.TIER_NOT_RECOMMENDED
+            summary = f"Requires {total_memory_gb:.1f} GB memory; exceeds total system capacity ({total_system_memory:.1f} GB)."
+            details.append("High probability of Out-Of-Memory (OOM) crash or extreme disk paging.")
+            est_tps = 0.5
+            return tier, summary, details, est_tps
+
+        # 100% Fits in GPU VRAM (or Apple Unified Memory)
+        if hw.gpu.detected and ram_offload <= 0.05 and vram_total >= total_memory_gb:
+            if billions <= 4.0:
+                tier = cls.TIER_EXCELLENT
+                est_tps = 45.0 if hw.gpu.backend == "CUDA" else 35.0
+                summary = f"Fits entirely inside {hw.gpu.name} ({vram_total:.1f} GB VRAM) with zero RAM offloading."
+                details.append("Maximum GPU acceleration with low latency.")
+            else:
+                tier = cls.TIER_RECOMMENDED
+                est_tps = 30.0 if hw.gpu.backend == "CUDA" else 25.0
+                summary = f"Comfortably accommodated in GPU VRAM with full {hw.gpu.backend} acceleration."
+                details.append("High interactive tokens/sec throughput.")
+            return tier, summary, details, est_tps
+
+        # Hybrid VRAM + RAM Offload
+        if hw.gpu.detected and vram_total >= 3.0:
+            offload_pct = (ram_offload / total_memory_gb) * 100.0
+            if offload_pct <= 45.0 and total_memory_gb <= (hw.ram.total_gb * 0.7):
+                tier = cls.TIER_RECOMMENDED
+                est_tps = 18.0
+                summary = f"Hybrid execution: {vram_used:.1f} GB in GPU VRAM + {ram_offload:.1f} GB offloaded to System RAM."
+                details.append(f"Fast execution with ~{int(100 - offload_pct)}% GPU compute acceleration.")
+            elif total_memory_gb <= (hw.ram.total_gb * 0.85):
+                tier = cls.TIER_USABLE
+                est_tps = 8.0
+                summary = f"Partial offload: {vram_used:.1f} GB in VRAM, {ram_offload:.1f} GB in System RAM."
+                details.append("Workable for background coding and general questions; generation speed is moderate.")
+            else:
+                tier = cls.TIER_HEAVY
+                est_tps = 2.5
+                summary = f"Heavy RAM offload ({ram_offload:.1f} GB); will utilize most available System RAM."
+                details.append("Technically runnable, but response generation will be CPU-bound and slow.")
+            return tier, summary, details, est_tps
+
+        # CPU Only Inference (No GPU or very small VRAM)
+        if total_memory_gb <= (hw.ram.total_gb * 0.45):
+            if billions <= 2.0:
+                tier = cls.TIER_RECOMMENDED
+                est_tps = 14.0
+                summary = "Compact architecture runs smoothly on modern CPU."
+            else:
+                tier = cls.TIER_USABLE
+                est_tps = 7.0
+                summary = f"Runs purely in System RAM ({total_memory_gb:.1f} GB) via CPU multi-threading."
+        elif total_memory_gb <= (hw.ram.total_gb * 0.8):
+            tier = cls.TIER_HEAVY
+            est_tps = 2.5
+            summary = f"Heavy CPU workload: requires {total_memory_gb:.1f} GB of {hw.ram.total_gb:.1f} GB System RAM."
+            details.append("Noticeable system slowdown may occur during generation.")
+        else:
+            tier = cls.TIER_NOT_RECOMMENDED
+            est_tps = 0.8
+            summary = f"Consumes {total_memory_gb:.1f} GB RAM; risks system freeze or paging."
+
+        return tier, summary, details, est_tps
+
+    def __init__(self, hw: Optional[HardwareProfile] = None):
+        self.hw = hw or HardwareAnalyzer.detect()
+        self.profile = self.hw
+
+    def evaluate(self, model_dict_or_name: Union[Dict[str, Any], str], context_len: int = 8192) -> CompatibilityReport:
+        if isinstance(model_dict_or_name, str):
+            name = model_dict_or_name
+            params = name
+            size_gb = 0.0
+        else:
+            name = model_dict_or_name.get("name", "model")
+            params = model_dict_or_name.get("params", name)
+            size_gb = float(model_dict_or_name.get("size_gb", 0.0))
+            context_len = int(model_dict_or_name.get("context", context_len))
+
+        return self.evaluate_model(
+            model_name=name,
+            params_str=params,
+            size_gb=size_gb,
+            context_len=context_len,
+            hardware=self.hw,
+        )
+
+    def recommend_models(self, catalog_models: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
+        """Categorize catalog models into optimal hardware-supported recommendations."""
+        evaluated = []
+        for m in catalog_models:
+            rep = self.evaluate(m)
+            evaluated.append({"model": m, "compat": rep})
+
+        # Filter to viable tiers
+        viable = [
+            e for e in evaluated
+            if e["compat"].tier in (self.TIER_EXCELLENT, self.TIER_RECOMMENDED, self.TIER_USABLE)
+        ]
+
+        def _sort_best(items):
+            order = {self.TIER_EXCELLENT: 0, self.TIER_RECOMMENDED: 1, self.TIER_USABLE: 2}
+            return sorted(items, key=lambda x: (order.get(x["compat"].tier, 9), -x["compat"].estimated_tps))
+
+        coding = [e for e in viable if "coding" in e["model"].get("categories", []) or "code" in e["model"].get("caps", [])]
+        reasoning = [e for e in viable if "reasoning" in e["model"].get("categories", []) or "reasoning" in e["model"].get("caps", [])]
+        fast = [e for e in viable if "small" in e["model"].get("categories", []) or e["compat"].estimated_tps >= 25.0]
+
+        return {
+            "best_coding": _sort_best(coding),
+            "best_reasoning": _sort_best(reasoning),
+            "best_fast": _sort_best(fast),
+            "all_viable": viable,
+        }

calc_terminal/compute/__init__.py

@@ -0,0 +1,31 @@
+"""
+CAT Compute Fabric Package per §25, §26, §87-§90.
+"""
+
+from __future__ import annotations
+
+from calc_terminal.compute.fabric import (
+    ComputeTarget,
+    ComputeTargetType,
+    ComputeTargetStatus,
+    LocalCPUTarget,
+    LocalGPUTarget,
+    OllamaTarget,
+    DockerTarget,
+    WSLTarget,
+    ComputeFabric,
+    compute_fabric,
+)
+
+__all__ = [
+    "ComputeTarget",
+    "ComputeTargetType",
+    "ComputeTargetStatus",
+    "LocalCPUTarget",
+    "LocalGPUTarget",
+    "OllamaTarget",
+    "DockerTarget",
+    "WSLTarget",
+    "ComputeFabric",
+    "compute_fabric",
+]