cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/identity.py

@@ -0,0 +1,216 @@
+"""
+calc_terminal/identity.py
+==========================
+Single source of truth for CCT's application identity: what CCT is, who
+made it, and what it's actually built with.
+
+Before this module existed, "who made you" style questions were answered
+in three different, drifting places: the AI's default system prompt (no
+creator info at all), the AGENT/AI system prompts in agent.py (also
+nothing), and a hidden easter egg in easter_eggs.py (vibes, no name).
+That's why the app used to give inconsistent or flatly wrong answers.
+
+Every one of those places now reads from here instead of hardcoding its
+own copy:
+  - aicore.py's default system prompts embed IDENTITY_BLOCK
+  - agent.py's AGENT_SYSTEM_PROMPT / AI_SYSTEM_PROMPT embed IDENTITY_BLOCK
+  - easter_eggs.py's "who made this" panel renders answer_creator()
+  - the Textual UI (ui/app.py) and the fallback CLI (app.py) both run a
+    deterministic fast-path intercept (is_identity_question / answer_for)
+    *before* ever reaching the AI, so the answer is 100% consistent no
+    matter which AI provider is active, whether it's offline, or how a
+    particular model happens to phrase things.
+
+tech_stack_sentence() never invents technology — it only ever reports the
+Python/Textual/engine core that's always true plus whatever AI provider
+is actually configured right now (from aicore's own config), so it can't
+drift out of sync with reality either.
+"""
+
+import re
+
+# --------------------------------------------------------------- facts --
+APP_NAME = "Coding Agent Terminal"
+SHORT_NAME = "CAT"
+APP_TAGLINE = "a terminal-based AI-powered coding and scientific workspace"
+APP_VERSION = "0.7.9.0"
+
+CLI_TITLE = "CAT CLI"
+CLI_EMOJI = "🐱"
+FULL_CLI_TITLE = f"{CLI_EMOJI} {CLI_TITLE}"
+
+CREATOR_NAME = "Kazi Zillani"
+CREATOR_ROLE = "a student and independent developer"
+DEVELOPMENT_NOTE = "designed and developed by a single developer"
+
+# Technology that's always part of CAT regardless of which AI backend
+# (if any) is currently configured.
+_CORE_TECH = [
+    "Python",
+    "the Textual terminal UI framework",
+    "a custom chemistry calculation engine",
+]
+
+_PROVIDER_LABELS = {
+    "openai": "OpenAI",
+    "anthropic": "Anthropic",
+    "gemini": "Google Gemini",
+    "openrouter": "OpenRouter",
+    "groq": "Groq",
+    "ollama": "a local Ollama model",
+}
+
+
+def _provider_phrase(config):
+    """Describe the currently configured AI backend truthfully, or return
+    None if nothing is configured — never guess a provider that isn't
+    actually active."""
+    if not config:
+        return None
+    provider = (config.get("provider") or "").strip().lower()
+    if not provider:
+        return None
+    model = (config.get("model") or "").strip()
+    label = _PROVIDER_LABELS.get(provider, provider)
+    if provider == "ollama":
+        return f"{label} (model: {model})" if model else label
+    return f"{label} (model: {model})" if model else label
+
+
+def tech_stack_parts(config=None):
+    """List of technology strings actually in play right now. `config`
+    should be aicore.load_config()'s return value, if available."""
+    parts = list(_CORE_TECH)
+    provider_phrase = _provider_phrase(config)
+    if provider_phrase:
+        parts.append(provider_phrase)
+    return parts
+
+
+def tech_stack_sentence(config=None):
+    parts = tech_stack_parts(config)
+    if len(parts) == 1:
+        return parts[0]
+    return ", ".join(parts[:-1]) + ", and " + parts[-1]
+
+
+# ------------------------------------------------------- system prompt --
+# Folded into every AI system prompt so the model itself stays accurate
+# even for identity phrasings the fast-path intercept below doesn't
+# happen to catch.
+IDENTITY_BLOCK = f"""[CAT IDENTITY \u2014 factual, do not deviate from this]
+You are running inside {APP_NAME} ({SHORT_NAME}), {APP_TAGLINE}.
+{SHORT_NAME} the application was created by {CREATOR_NAME}, {CREATOR_ROLE} \u2014 {DEVELOPMENT_NOTE}.
+You (the AI answering right now) are a separate thing from {SHORT_NAME} itself: {SHORT_NAME} is the app/terminal the person is typing into; the AI is whichever model provider is currently configured. Never claim {CREATOR_NAME} built or trained the underlying AI model \u2014 only the {SHORT_NAME} application around it.
+If asked who made/built/created/developed {SHORT_NAME}, or who owns this project: the answer is {CREATOR_NAME}, {CREATOR_ROLE}.
+If asked what AI model or provider is answering: name the actual configured provider/model, never {CREATOR_NAME}.
+Never invent capabilities, companies, or technologies that aren't actually part of {SHORT_NAME}."""
+
+
+# ---------------------------------------------------- deterministic Q&A --
+# A fast-path for the most common phrasings, answered directly from this
+# module with zero AI involved, so the answer can never depend on model
+# mood, provider, or connectivity. Broader than an exact-match easter
+# egg on purpose: "who built cat", "who owns this project", "who
+# developed you" etc. should all land here, not just one exact string.
+_CREATOR_PATTERNS = [
+    r"\bwho\b[^.?!]{0,40}\b(made|built|created|developed|designed|coded|wrote|owns)\b[^.?!]{0,25}\b(you|this|it|cat|cct|the app|the application|the project|coding agent terminal)\b",
+    r"\bwho(?:'s| is)\b[^.?!]{0,25}\b(creator|developer|maker|author|owner)\b",
+    r"\bwho\s+(?:made|built|created|developed|owns)\s+(?:cat|cct)\b",
+]
+_WHAT_ARE_YOU_PATTERNS = [
+    r"^\s*what\s+are\s+you\s*\??\s*$",
+    r"^\s*who\s+are\s+you\s*\??\s*$",
+    r"^\s*whoareyou\s*\??\s*$",
+    r"^\s*whatareyou\s*\??\s*$",
+    r"\bwhat\s+is\s+cat\b",
+    r"\bwhat\s+is\s+cct\b",
+    r"\bwhat\s+is\s+coding\s+agent\s+terminal\b",
+    # handle concatenated like Hi,howcanIhelpyou?User:whoareyou?
+    r"who\s*are\s*you",
+    r"what\s*are\s*you",
+]
+_MODEL_PATTERNS = [
+    r"\bwhat\s+(?:ai\s+)?model\b[^.?!]{0,25}\b(are you|is this|using|running|powered by)\b",
+    r"\bwhich\s+(?:ai\s+)?model\b",
+    r"\bwhat\s+llm\b",
+]
+
+_CREATOR_RE = re.compile("|".join(_CREATOR_PATTERNS), re.IGNORECASE)
+_WHAT_ARE_YOU_RE = re.compile("|".join(_WHAT_ARE_YOU_PATTERNS), re.IGNORECASE)
+_MODEL_RE = re.compile("|".join(_MODEL_PATTERNS), re.IGNORECASE)
+
+
+def classify_identity_question(text):
+    """Return 'model', 'creator', 'what', or None. Checked in this order
+    so 'what AI model are you using' (a model question) doesn't get
+    swallowed by the broader 'what are you' pattern."""
+    t = (text or "").strip()
+    if not t:
+        return None
+    if _MODEL_RE.search(t):
+        return "model"
+    if _CREATOR_RE.search(t):
+        return "creator"
+    if _WHAT_ARE_YOU_RE.search(t):
+        return "what"
+    return None
+
+
+def is_identity_question(text):
+    return classify_identity_question(text) is not None
+
+
+def answer_creator(config=None):
+    return (
+        f"{SHORT_NAME} ({APP_NAME}) was created by {CREATOR_NAME}, {CREATOR_ROLE} \u2014 "
+        f"{DEVELOPMENT_NOTE}.\n"
+        f"Under the hood it's built with {tech_stack_sentence(config)}."
+    )
+
+
+def answer_what(config=None):
+    return (
+        f"{SHORT_NAME} is {APP_TAGLINE}. It's built with {tech_stack_sentence(config)}, "
+        f"created by {CREATOR_NAME}, {CREATOR_ROLE}."
+    )
+
+
+def answer_model(config=None):
+    provider_phrase = _provider_phrase(config)
+    if not provider_phrase:
+        return (
+            f"No AI provider is configured for {SHORT_NAME} right now \u2014 run /model to set "
+            f"one up. That's separate from {SHORT_NAME} itself, which was created by "
+            f"{CREATOR_NAME}, {CREATOR_ROLE}."
+        )
+    return (
+        f"Right now {SHORT_NAME} is talking to you through {provider_phrase}. That's the "
+        f"underlying AI provider, not {SHORT_NAME} itself \u2014 the {SHORT_NAME} application "
+        f"around it was created by {CREATOR_NAME}."
+    )
+
+
+def answer_for(text, config=None):
+    """Return the canonical answer for an identity question, or None if
+    `text` isn't one."""
+    kind = classify_identity_question(text)
+    if kind == "creator":
+        return answer_creator(config)
+    if kind == "model":
+        return answer_model(config)
+    if kind == "what":
+        return answer_what(config)
+    return None
+
+
+# Re-export terminal identity functions for convenience
+from .terminal_identity import (
+    set_terminal_title,
+    restore_terminal_title,
+    init_terminal_identity,
+    get_icon_path,
+    configure_windows_terminal_profile,
+    start_title_guard,
+    stop_title_guard,
+)

calc_terminal/input/__init__.py

@@ -0,0 +1,54 @@
+"""
+CAT Input Architecture Module
+Centralized input abstraction for touchscreens, 2-in-1s, mice, and keyboards.
+"""
+
+from .capabilities import (
+    DeviceType,
+    InputCapabilities,
+    detect_capabilities,
+    get_input_capabilities,
+    set_touch_mode,
+    toggle_touch_mode,
+    register_listener,
+    unregister_listener,
+)
+from .touch import (
+    TouchTapRecognizer,
+    TouchScrollHandler,
+    TAP_MAX_DISTANCE,
+    TAP_MAX_DURATION,
+    DOUBLE_TAP_MAX_DELAY,
+    LONG_PRESS_DURATION,
+)
+from .pointer import (
+    TouchHitZone,
+    RESIZER_TOUCH_PADDING,
+)
+from .focus import (
+    TouchFocusManager,
+)
+from .gestures import (
+    GestureBridge,
+)
+
+__all__ = [
+    "DeviceType",
+    "InputCapabilities",
+    "detect_capabilities",
+    "get_input_capabilities",
+    "set_touch_mode",
+    "toggle_touch_mode",
+    "register_listener",
+    "unregister_listener",
+    "TouchTapRecognizer",
+    "TouchScrollHandler",
+    "TAP_MAX_DISTANCE",
+    "TAP_MAX_DURATION",
+    "DOUBLE_TAP_MAX_DELAY",
+    "LONG_PRESS_DURATION",
+    "TouchHitZone",
+    "RESIZER_TOUCH_PADDING",
+    "TouchFocusManager",
+    "GestureBridge",
+]

calc_terminal/input/capabilities.py

@@ -0,0 +1,258 @@
+"""
+CAT Input Architecture — capabilities.py
+Runtime input device detection and capabilities abstraction.
+
+Detects:
+- Touchscreen presence and maximum concurrent touch points (Win32 SM_MAXIMUMTOUCHES, SM_DIGITIZER)
+- Mouse availability (SM_MOUSEPRESENT)
+- Convertible / 2-in-1 slate mode (SM_CONVERTIBLESLATEMODE)
+- Tablet PC capabilities (SM_TABLETPC)
+- Display scaling / DPI awareness
+
+Classifies runtime environment into:
+- Normal Desktop
+- Touchscreen Laptop
+- 2-in-1 / Convertible
+- Tablet-style Windows Device
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import json
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Optional, Callable, List
+
+CONFIG_PATH = os.path.join(os.path.expanduser("~"), ".cct_config.json")
+
+
+class DeviceType(str, Enum):
+    DESKTOP = "desktop"
+    TOUCHSCREEN_LAPTOP = "touchscreen_laptop"
+    CONVERTIBLE_2IN1 = "convertible_2in1"
+    TABLET_WINDOWS = "tablet_windows"
+
+    @property
+    def display_name(self) -> str:
+        if self == DeviceType.TOUCHSCREEN_LAPTOP:
+            return "Touchscreen Laptop"
+        if self == DeviceType.CONVERTIBLE_2IN1:
+            return "2-in-1 / Convertible"
+        if self == DeviceType.TABLET_WINDOWS:
+            return "Tablet-style Windows Device"
+        return "Normal Desktop"
+
+
+@dataclass
+class InputCapabilities:
+    """Centralized input capability descriptor reusable across CAT UI."""
+    touchscreen_available: bool = False
+    mouse_available: bool = True
+    keyboard_available: bool = True
+    touch_primary: bool = False
+    touch_mode_enabled: bool = False
+    max_touch_points: int = 0
+    device_type: DeviceType = DeviceType.DESKTOP
+    slate_mode: bool = False
+    scaling_factor: float = 1.0
+
+    def to_dict(self) -> dict:
+        return {
+            "touchscreen_available": self.touchscreen_available,
+            "mouse_available": self.mouse_available,
+            "keyboard_available": self.keyboard_available,
+            "touch_primary": self.touch_primary,
+            "touch_mode_enabled": self.touch_mode_enabled,
+            "max_touch_points": self.max_touch_points,
+            "device_type": self.device_type.value,
+            "device_name": self.device_type.display_name,
+            "slate_mode": self.slate_mode,
+            "scaling_factor": self.scaling_factor,
+        }
+
+
+# Listeners for capability changes (e.g. tablet flip, touch mode toggle)
+_LISTENERS: List[Callable[[InputCapabilities], None]] = []
+_CURRENT_CAPABILITIES: Optional[InputCapabilities] = None
+
+
+def _read_config_touch_mode() -> Optional[bool]:
+    """Read user-configured touch mode preference from ~/.cct_config.json if set."""
+    try:
+        if os.path.exists(CONFIG_PATH):
+            with open(CONFIG_PATH, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, dict) and "touch_mode" in data:
+                    val = data["touch_mode"]
+                    if isinstance(val, bool):
+                        return val
+    except Exception:
+        pass
+    return None
+
+
+def _save_config_touch_mode(enabled: bool) -> None:
+    """Save user touch mode toggle to ~/.cct_config.json."""
+    try:
+        data = {}
+        if os.path.exists(CONFIG_PATH):
+            try:
+                with open(CONFIG_PATH, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+            except Exception:
+                data = {}
+        data["touch_mode"] = bool(enabled)
+        with open(CONFIG_PATH, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+    except Exception:
+        pass
+
+
+def detect_capabilities() -> InputCapabilities:
+    """Perform real runtime capability detection on Windows and cross-platform."""
+    touchscreen_available = False
+    mouse_available = True
+    keyboard_available = True
+    max_touch_points = 0
+    slate_mode = False
+    is_tablet_pc = False
+    slate_mode_val = None
+    device_type = DeviceType.DESKTOP
+    scaling_factor = 1.0
+
+    # Win32 detection
+    if sys.platform == "win32":
+        try:
+            import ctypes
+            user32 = ctypes.windll.user32
+
+            # SM_DIGITIZER (94)
+            # 0x01 = NID_INTEGRATED_TOUCH, 0x02 = NID_EXTERNAL_TOUCH, 0x40 = NID_MULTI_INPUT, 0x80 = NID_READY
+            digitizer_val = user32.GetSystemMetrics(94)
+            # SM_MAXIMUMTOUCHES (95) - returns number of touches or 0
+            max_touches = user32.GetSystemMetrics(95)
+            max_touch_points = max(0, int(max_touches))
+
+            # SM_MOUSEPRESENT (19)
+            mouse_present = user32.GetSystemMetrics(19)
+            mouse_available = bool(mouse_present)
+
+            # SM_TABLETPC (86)
+            tablet_pc_val = user32.GetSystemMetrics(86)
+            is_tablet_pc = bool(tablet_pc_val)
+
+            # SM_CONVERTIBLESLATEMODE (0x2003 = 8195)
+            # 0 = laptop/clamshell mode, 1 = slate/tablet mode
+            slate_mode_val = user32.GetSystemMetrics(0x2003)
+            slate_mode = bool(slate_mode_val == 1)
+
+            # If max touches > 0 or digitizer has touch bits
+            if max_touch_points > 0 or (digitizer_val & 0x03):
+                touchscreen_available = True
+
+            # DPI detection
+            try:
+                dpi = user32.GetDpiForSystem()
+                if dpi > 0:
+                    scaling_factor = round(dpi / 96.0, 2)
+            except (AttributeError, Exception):
+                scaling_factor = 1.0
+
+        except Exception:
+            # Fallback if ctypes or user32 fails
+            touchscreen_available = False
+            mouse_available = True
+
+    # Device Classification
+    if touchscreen_available:
+        if slate_mode or (is_tablet_pc and not mouse_available):
+            device_type = DeviceType.TABLET_WINDOWS
+        elif is_tablet_pc or slate_mode_val == 0:
+            # Device has 2-in-1 sensor or convertible capability
+            device_type = DeviceType.CONVERTIBLE_2IN1
+        else:
+            device_type = DeviceType.TOUCHSCREEN_LAPTOP
+    else:
+        device_type = DeviceType.DESKTOP
+
+    # Touch Primary determination
+    touch_primary = False
+    if device_type == DeviceType.TABLET_WINDOWS or slate_mode:
+        touch_primary = True
+
+    # Touch Mode Enabled determination:
+    # 1. Environment variable override: CCT_TOUCH_MODE=1 / 0
+    # 2. Config file preference: ~/.cct_config.json -> touch_mode
+    # 3. Default: True if touchscreen is detected, False otherwise
+    env_override = os.environ.get("CCT_TOUCH_MODE", "").strip().lower()
+    config_pref = _read_config_touch_mode()
+
+    if env_override in ("1", "true", "yes", "on"):
+        touch_mode_enabled = True
+    elif env_override in ("0", "false", "no", "off"):
+        touch_mode_enabled = False
+    elif config_pref is not None:
+        touch_mode_enabled = config_pref
+    else:
+        touch_mode_enabled = bool(touchscreen_available)
+
+    return InputCapabilities(
+        touchscreen_available=touchscreen_available,
+        mouse_available=mouse_available,
+        keyboard_available=keyboard_available,
+        touch_primary=touch_primary,
+        touch_mode_enabled=touch_mode_enabled,
+        max_touch_points=max_touch_points,
+        device_type=device_type,
+        slate_mode=slate_mode,
+        scaling_factor=scaling_factor,
+    )
+
+
+def get_input_capabilities(force_refresh: bool = False) -> InputCapabilities:
+    """Get or initialize the cached input capabilities."""
+    global _CURRENT_CAPABILITIES
+    if _CURRENT_CAPABILITIES is None or force_refresh:
+        _CURRENT_CAPABILITIES = detect_capabilities()
+    return _CURRENT_CAPABILITIES
+
+
+def set_touch_mode(enabled: bool, persist: bool = True) -> InputCapabilities:
+    """Explicitly enable or disable touch-friendly mode."""
+    caps = get_input_capabilities()
+    caps.touch_mode_enabled = bool(enabled)
+    if persist:
+        _save_config_touch_mode(caps.touch_mode_enabled)
+    _notify_listeners(caps)
+    return caps
+
+
+def toggle_touch_mode(persist: bool = True) -> bool:
+    """Toggle touch-friendly mode on or off."""
+    caps = get_input_capabilities()
+    new_state = not caps.touch_mode_enabled
+    set_touch_mode(new_state, persist=persist)
+    return new_state
+
+
+def register_listener(callback: Callable[[InputCapabilities], None]) -> None:
+    """Register a listener invoked when input capabilities or touch mode changes."""
+    if callback not in _LISTENERS:
+        _LISTENERS.append(callback)
+
+
+def unregister_listener(callback: Callable[[InputCapabilities], None]) -> None:
+    """Unregister a capability listener."""
+    if callback in _LISTENERS:
+        _LISTENERS.remove(callback)
+
+
+def _notify_listeners(caps: InputCapabilities) -> None:
+    for cb in list(_LISTENERS):
+        try:
+            cb(caps)
+        except Exception:
+            pass

calc_terminal/input/focus.py

@@ -0,0 +1,87 @@
+"""
+CAT Input Architecture — focus.py
+Touch-friendly focus management and virtual/on-screen keyboard adaptation.
+
+Prevents focus jumping, preserves text input focus when Windows touch keyboard appears,
+and manages focus restoration on modal/popup dismissals.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+from textual.widget import Widget
+from textual.widgets import Input, TextArea
+
+
+class TouchFocusManager:
+    """Manages focus state, input activation, and focus restoration for touchscreen interactions."""
+
+    def __init__(self):
+        self._last_focused: Optional[Widget] = None
+        self._previous_screen_focus: Optional[Widget] = None
+
+    def on_touch_tap_widget(self, target: Optional[Widget]) -> None:
+        """Ensure tapped text inputs receive immediate and stable focus."""
+        if target is None:
+            return
+
+        # Check if the target is an editable input or inside one
+        cur = target
+        input_widget = None
+        while cur is not None:
+            if isinstance(cur, (Input, TextArea)):
+                input_widget = cur
+                break
+            cur = getattr(cur, "parent", None)
+
+        if input_widget is not None and getattr(input_widget, "can_focus", True):
+            try:
+                if not input_widget.has_focus:
+                    input_widget.focus()
+                self._last_focused = input_widget
+            except Exception:
+                pass
+            return
+
+        # Check if target is inside composer card (prompt glyph, prompt row, card margin)
+        cur = target
+        inside_composer = False
+        is_button = False
+        from textual.widgets import Button
+        while cur is not None:
+            if getattr(cur, "id", None) == "cct-composer":
+                inside_composer = True
+            if isinstance(cur, (Button,)):
+                is_button = True
+            cur = getattr(cur, "parent", None)
+        if inside_composer and not is_button:
+            try:
+                app = getattr(target, "app", None)
+                if app is not None:
+                    composer_input = app.query_one("#cct-input", TextArea)
+                    if composer_input is not None and not composer_input.has_focus:
+                        composer_input.focus()
+                        self._last_focused = composer_input
+                        return
+            except Exception:
+                pass
+
+        if getattr(target, "can_focus", False):
+            try:
+                self._last_focused = target
+            except Exception:
+                pass
+
+    def save_focus(self, widget: Optional[Widget]) -> None:
+        """Save active focus before opening a modal or popup."""
+        self._previous_screen_focus = widget or self._last_focused
+
+    def restore_focus(self) -> None:
+        """Restore saved focus after modal or popup dismisses."""
+        if self._previous_screen_focus is not None:
+            try:
+                if self._previous_screen_focus.is_attached and getattr(self._previous_screen_focus, "can_focus", False):
+                    self._previous_screen_focus.focus()
+            except Exception:
+                pass
+            self._previous_screen_focus = None

calc_terminal/input/gestures.py

@@ -0,0 +1,64 @@
+"""
+CAT Input Architecture — gestures.py
+Touchscreen gesture integration with CAT Gestures Extension.
+
+Connects touch interactions (tap, double-tap, long-press, swipe) to the
+existing Gestures extension without creating duplicate backends.
+Works safely even when the Gestures extension is disabled.
+"""
+
+from __future__ import annotations
+
+from typing import Optional, Dict, Any
+from textual.widget import Widget
+from textual.app import App
+
+
+class GestureBridge:
+    """Bridges touch gestures into the CAT Gestures subsystem."""
+
+    @classmethod
+    def dispatch_touch_gesture(
+        cls,
+        trigger: str,
+        target: str,
+        app: Optional[App] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        """
+        Dispatch a gesture to calc_terminal.gestures.manager.
+        Returns True if an enabled action was triggered, False otherwise.
+        """
+        try:
+            from ..gestures.manager import handle_gesture
+            # Map double_tap to double_click for gesture registry compatibility
+            mapped_trigger = "double_click" if trigger == "double_tap" else trigger
+            return bool(handle_gesture(mapped_trigger, target, app=app, context=context or {}))
+        except Exception:
+            return False
+
+    @classmethod
+    def resolve_target_surface(cls, widget: Optional[Widget]) -> str:
+        """Map a Textual widget to a Gestures target surface (editor, chat, file, diff, preview, explorer)."""
+        if widget is None:
+            return "global"
+
+        cur = widget
+        while cur is not None:
+            wid = getattr(cur, "id", "") or ""
+            cls_name = cur.__class__.__name__
+
+            if wid == "cct-editor" or "EditorPane" in cls_name or "TextArea" in cls_name:
+                return "editor"
+            if wid == "cct-conversation" or "Conversation" in cls_name or "MessageRow" in cls_name:
+                return "chat"
+            if wid in ("cct-sidebar", "cct-sidebar-body") or "DirectoryTree" in cls_name or "Explorer" in cls_name:
+                return "file"
+            if wid == "cct-preview" or "Preview" in cls_name:
+                return "preview"
+            if "diff" in wid.lower() or "Diff" in cls_name:
+                return "diff"
+
+            cur = getattr(cur, "parent", None)
+
+        return "global"