cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/ui/palette.py

@@ -0,0 +1,221 @@
+"""
+CCT UI — the "/" command palette. Filters calc_terminal/commands_data.py's
+COMMANDS (the SAME list the fallback CLI's /help prints — one registry,
+not a second hand-maintained copy), renders the dropdown, and posts
+CommandExecuted when a command is chosen. Deciding what a command does
+is calc_terminal/app.py's job, not this module's.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+from ..commands_data import COMMANDS
+
+TEXTUAL_AVAILABLE = True
+try:
+    from textual.containers import Vertical
+    from textual.widgets import Static
+except Exception:
+    TEXTUAL_AVAILABLE = False
+
+PROMPT_SUGGESTIONS = [
+    # Kinetics & Numerical Chemistry
+    ("what is a first order reaction", "Quick conceptual answer · Kinetics"),
+    ("half life of a first order reaction", "Numerical calculation · Kinetics"),
+    ("explain the arrhenius equation simply", "Conceptual explanation · Physical Chem"),
+    ("what's the difference between molarity and molality", "Concentration comparison · Solutions"),
+    ("quick mole concept refresher", "Core principles & formulas · Class 11"),
+    ("how to balance redox reactions", "Ion-electron oxidation-reduction method"),
+    ("calculate molar mass of glucose", "Step-by-step formula C6H12O6 mass"),
+    ("activation energy numerical", "Arrhenius rate constant equation"),
+    ("zero order reaction half life", "Zero order rate formula & graph"),
+    ("second order kinetics rate constant", "Integrated rate equation derivation"),
+    ("calculate gibbs free energy delta G", "Thermodynamics spontaneity calculation"),
+    ("calculate ph of weak acid solution", "Equilibrium pH & dissociation constant"),
+    # Physics, Solves, Derivations & Simulations
+    ("solve ideal gas law with P=1, n=2, T=300", "Symbolic solve + full notebook"),
+    ("derive the first order rate law step by step", "Full derivation, notebook format"),
+    ("plot the arrhenius graph and export it", "Interactive plot + PNG export"),
+    ("plot y = sin(x)*exp(-x/5) from 0 to 20", "Damped wave function plot"),
+    ("simulate an iron atom in 3d", "Live 3D Bohr electron simulation"),
+    ("show me the 2p orbital cloud", "Quantum orbital 3D probability density"),
+    ("explain redox titration in detail", "Full reaction mechanism & calculations"),
+    ("integrate x*exp(-x^2) dx from 0 to infinity", "Calculus definite integration"),
+]
+
+
+class SuggestionEngine:
+    """Pure filtering logic — no widgets, so it's independently testable
+    and reusable anywhere a command or prompt list needs fuzzy filtering."""
+
+    @staticmethod
+    def fuzzy_score(query, candidate):
+        """Every character of `query` (lowercased) must appear in
+        `candidate` in order. Returns a score (lower is better) or None
+        if it doesn't match — a subsequence match is good enough for a
+        few dozen commands without pulling in a dependency."""
+        query = query.lower()
+        candidate = candidate.lower()
+        if not query:
+            return 0
+        if query in candidate:
+            return candidate.index(query)
+        pos = 0
+        gaps = 0
+        for ch in query:
+            found = candidate.find(ch, pos)
+            if found == -1:
+                return None
+            gaps += found - pos
+            pos = found + 1
+        return 100 + gaps
+
+    _HIDDEN_IN_CHAT = {"/notebook", "/workspace", "/kinetics", "/orbitals"}
+
+    @classmethod
+    def match(cls, query, limit=30):
+        query = (query or "").strip()
+        scored = []
+        is_cmd_query = query.startswith("/")
+        search_term = query[1:].strip() if is_cmd_query else query
+
+        # 1. Match slash commands
+        for cmd, desc in COMMANDS:
+            if cmd in cls._HIDDEN_IN_CHAT:
+                continue
+            if is_cmd_query:
+                # Slash query: match against command name
+                score = cls.fuzzy_score(search_term, cmd[1:])
+            elif search_term:
+                # Plain text: match against command name as fallback
+                score = cls.fuzzy_score(search_term, cmd[1:])
+                if score is not None:
+                    score += 25
+            else:
+                score = None
+
+            if score is not None:
+                scored.append((score, cmd, desc))
+
+        # 2. Match prompt suggestions
+        for prompt_text, desc in PROMPT_SUGGESTIONS:
+            if not search_term:
+                # Top prompt suggestions after commands
+                score = 35 if is_cmd_query else 10
+            else:
+                score = cls.fuzzy_score(search_term, prompt_text)
+                if score is not None and is_cmd_query:
+                    score += 20  # Prefer slash commands when user explicitly typed '/'
+                if score is None:
+                    words = search_term.lower().split()
+                    if words and all(w in prompt_text.lower() or w in desc.lower() for w in words):
+                        score = 50 if is_cmd_query else 40
+            if score is not None:
+                scored.append((score, prompt_text, desc))
+
+        scored.sort(key=lambda t: t[0])
+        return [(item, desc) for _, item, desc in scored[:limit]]
+
+
+if TEXTUAL_AVAILABLE:
+    from textual.containers import VerticalScroll
+
+    PAGE_SIZE = 6
+
+    class CommandPalette(VerticalScroll):
+        """The command and prompt suggestions palette — mounted inline inside
+        the composer card. ComposerInput drives it: Up/Down/PageUp/PageDown
+        move selection, Tab/Enter accept it, Esc closes it, and clicking
+        any item selects it."""
+
+        def __init__(self, id="cct-cmdpalette"):
+            super().__init__(id=id)
+            self._matches = []
+            self._selected = 0
+
+        def compose(self):
+            yield from ()
+
+        def is_open(self):
+            return self.has_class("open")
+
+        def open_for_query(self, query):
+            self._matches = SuggestionEngine.match(query)
+            if not self._matches:
+                self.close()
+                return
+            self._selected = min(self._selected, len(self._matches) - 1)
+            self._redraw()
+            self.add_class("open")
+            # Dynamically size between 3 and 7 rows
+            self.styles.height = min(7, max(3, len(self._matches)))
+            self.scroll_home(animate=False)
+            if self.parent and hasattr(self.parent, "_on_palette_state_changed"):
+                self.parent._on_palette_state_changed(True)
+
+        def close(self):
+            was_open = self.is_open()
+            self._matches = []
+            self._selected = 0
+            self.remove_class("open")
+            for child in list(self.children):
+                child.remove()
+            if was_open and self.parent and hasattr(self.parent, "_on_palette_state_changed"):
+                self.parent._on_palette_state_changed(False)
+
+        def on_click(self, event):
+            try:
+                for i, child in enumerate(self.children):
+                    if child == event.widget or child in getattr(event.widget, "ancestors", []):
+                        self._selected = i
+                        self._redraw()
+                        if self.parent and hasattr(self.parent, "on_palette_selected"):
+                            self.parent.on_palette_selected(self.selected_command())
+                        break
+            except Exception:
+                pass
+
+        def move(self, delta):
+            if not self._matches:
+                return
+            self._selected = (self._selected + delta) % len(self._matches)
+            self._redraw()
+            self._scroll_selected_into_view()
+
+        def move_page(self, direction):
+            if not self._matches:
+                return
+            last = len(self._matches) - 1
+            self._selected = max(0, min(last, self._selected + direction * PAGE_SIZE))
+            self._redraw()
+            self._scroll_selected_into_view()
+
+        def selected_command(self):
+            if not self._matches:
+                return None
+            return self._matches[self._selected][0]
+
+        def _scroll_selected_into_view(self):
+            try:
+                rows = list(self.query(".cct-cmd-row"))
+                if 0 <= self._selected < len(rows):
+                    self.scroll_to_widget(rows[self._selected], animate=True)
+            except Exception:
+                pass
+
+        def _redraw(self):
+            from . import theme_css
+            accent = theme_css.current_hex("accent")
+            for child in list(self.children):
+                child.remove()
+            for i, (item, desc) in enumerate(self._matches):
+                classes = "cct-cmd-row" + (" cct-cmd-row-selected" if i == self._selected else "")
+                if item.startswith("/"):
+                    self.mount(Static(f"[{accent} b]{item}[/]  [dim]{desc}[/dim]", classes=classes))
+                else:
+                    self.mount(Static(f"[{accent}]\u2726[/] {item}  [dim]{desc}[/dim]", classes=classes))
+
+else:
+    CommandPalette = None

calc_terminal/ui/permission_panel.py

@@ -0,0 +1,269 @@
+"""
+CCT UI — the single permission renderer. Two widgets, both reading and
+writing through calc_terminal/permissions.py's shared PermissionManager
+(the one source of truth for permission state — this module never
+tracks its own copy):
+
+  * PermissionCard — an inline "AI wants permission" request, mounted
+    as a ConversationItem in the conversation stream (per the redesign
+    brief: "Permission requests become part of conversation history",
+    never a modal/popup).
+  * PermissionsSettingsPanel — the full on/off checklist, opened from
+    the footer's Permissions button.
+
+Both post events (PermissionGranted/PermissionDenied/PermissionCancelled)
+rather than deciding what a decision means — calc_terminal/permissions.py
+records it, calc_terminal/ui/app.py resolves whatever backend call was
+waiting.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+from .. import permissions as perm
+from .events import PermissionGranted, PermissionDenied, PermissionCancelled
+
+TEXTUAL_AVAILABLE = True
+try:
+    from textual.containers import Horizontal, Vertical
+    from textual.widgets import Static, Button, Switch, Label
+except Exception:
+    TEXTUAL_AVAILABLE = False
+
+
+if TEXTUAL_AVAILABLE:
+
+    class PermissionCard(Vertical):
+        """Inline 'AI wants permission' request — mounted into the
+        conversation log as its own item, never a popup."""
+
+        def __init__(self, request_id, key, action_text, reason_text, id=None, path=None):
+            super().__init__(id=id, classes="cct-permcard")
+            self.request_id = request_id
+            self.key = key
+            self._action_text = action_text
+            self._reason_text = reason_text
+            self._path = path
+            self._resolved = False
+
+        def compose(self):
+            # Restricted mode (spec Mode 2) reviews this as a suggested
+            # patch — Accept/Reject — instead of Ask mode's (spec Mode 1)
+            # Allow-Once/Always-Allow/Deny. Same request, same event
+            # contract either way; only the labels/verb change.
+            self._restricted = perm.manager.restricted_review(self.key)
+            title = "Suggested action \u2014 review required" if self._restricted else "Permission required"
+            yield Static(title, classes="cct-permcard-title")
+            yield Static(f"The AI wants to [b]{self._action_text}[/b]")
+            if self._path:
+                yield Static(f"Path: {self._path}", classes="cct-permcard-path")
+            yield Static(f"Reason: {self._reason_text}", classes="cct-permcard-reason")
+            with Horizontal(classes="cct-permcard-buttons"):
+                if self._restricted:
+                    yield Button("Accept", id="allow-once", classes="cct-ctrl")
+                    yield Button("Reject", id="deny", classes="cct-ctrl")
+                else:
+                    # v0.7.7 spec section 3: the dialog offers five
+                    # choices — Allow Once / Always Allow / Deny /
+                    # Always Deny / Cancel (wrapped on a second row so
+                    # the card stays compact).
+                    yield Button("Allow Once", id="allow-once", classes="cct-ctrl")
+                    yield Button("Always Allow", id="always-allow", classes="cct-ctrl")
+                    yield Button("Deny", id="deny", classes="cct-ctrl")
+            if not self._restricted:
+                with Horizontal(classes="cct-permcard-buttons"):
+                    yield Button("Always Deny", id="always-deny", classes="cct-ctrl")
+                    yield Button("Cancel", id="cancel", classes="cct-ctrl")
+
+        def on_button_pressed(self, event: Button.Pressed):
+            if self._resolved:
+                return
+            self._resolved = True
+            bid = event.button.id
+            for b in self.query(Button):
+                b.disabled = True
+            from . import theme_css
+            if bid == "always-allow":
+                self.post_message(PermissionGranted(self.request_id, self.key, remember=True))
+                tone = "success"
+                verb = "always allow"
+            elif bid == "allow-once":
+                self.post_message(PermissionGranted(self.request_id, self.key, remember=False))
+                tone = "success"
+                verb = "accept" if getattr(self, "_restricted", False) else "allow once"
+            elif bid == "always-deny":
+                # v0.7.7: permanent (session) refusal — recorded in the
+                # shared PermissionManager so future requests for this
+                # key are refused without prompting at all.
+                self.post_message(PermissionDenied(self.request_id, self.key, remember=True))
+                tone = "error"
+                verb = "always deny"
+            elif bid == "cancel":
+                self.post_message(PermissionCancelled(self.request_id, self.key))
+                tone = "warn"
+                verb = "cancel"
+            else:
+                self.post_message(PermissionDenied(self.request_id, self.key, remember=False))
+                tone = "error"
+                verb = "reject" if getattr(self, "_restricted", False) else "deny"
+            color = theme_css.current_hex(tone)
+            self.mount(Static(f"[{color}]\u2192 {verb}[/]", classes="cct-permcard-verdict"))
+
+    class Toggle3D(Button):
+        """Skeuomorphic 3D On/Off tactile slider switch with physical rail,
+        depression animation, and glowing state indicator."""
+
+        def __init__(self, key, is_on=False, on_toggle=None):
+            self._key = key
+            self.is_on = is_on
+            self._on_toggle = on_toggle
+            super().__init__(
+                self._format_label(is_on),
+                id=f"perm-toggle-{key}",
+                classes="cct-toggle-3d " + ("-on" if is_on else "-off"),
+            )
+            self.can_focus = True
+
+        @staticmethod
+        def _format_label(is_on: bool) -> str:
+            # Tactile physical slider switch with 3D track and knob
+            return "[──● ON ]" if is_on else "[○── OFF]"
+
+        @property
+        def is_enabled(self) -> bool:
+            return self.is_on
+
+        def on_button_pressed(self, event: Button.Pressed):
+            event.stop()
+            self.is_on = not self.is_on
+            self.set_class(self.is_on, "-on")
+            self.set_class(not self.is_on, "-off")
+            self.label = self._format_label(self.is_on)
+            perm.manager.set(self._key, self.is_on)
+            if self._on_toggle:
+                self._on_toggle(self._key, self.is_on)
+
+    class PermissionRow(Horizontal):
+        """One checklist line inside PermissionsSettingsPanel: a label
+        and a 3D tactile On/Off switch."""
+
+        def __init__(self, key, label, is_on):
+            super().__init__(classes="cct-perm-row")
+            self._key = key
+            self._label_text = label
+            self._is_on = is_on
+
+        def compose(self):
+            from . import theme_css
+            color = theme_css.current_hex("success" if self._is_on else "text-muted")
+            mark = "●" if self._is_on else "○"
+            yield Static(f"[{color}]{mark}[/] {self._label_text}", classes="cct-perm-label")
+            yield Toggle3D(self._key, self._is_on, on_toggle=self._on_toggle_changed)
+
+        def _on_toggle_changed(self, key, value):
+            from . import theme_css
+            self._is_on = value
+            color = theme_css.current_hex("success" if value else "text-muted")
+            mark = "●" if value else "○"
+            try:
+                self.query_one(".cct-perm-label", Static).update(f"[{color}]{mark}[/] {self._label_text}")
+            except Exception:
+                pass
+
+    class PermissionsSettingsPanel(Vertical):
+        """Redesigned 3D Skeuomorphic Permissions & Settings Dashboard with
+        header bar, security mode cycler, close button, and 2-column organized grid."""
+
+        def __init__(self, id="cct-permission-panel"):
+            super().__init__(id=id)
+
+        @property
+        def is_open(self) -> bool:
+            return self.has_class("open")
+
+        def _mode_badge_text(self):
+            mode = getattr(perm.manager, "mode", "ask")
+            return perm.MODE_LABELS.get(mode, "🔒 Ask Every Time")
+
+        def compose(self):
+            # 1. Header Bar: Icon, Title, Mode Badge Cycler, and Close Button
+            with Horizontal(id="cct-perm-header"):
+                with Horizontal(id="cct-perm-title-box"):
+                    yield Static("🛡", id="cct-perm-icon")
+                    yield Static("Permissions & Security Controls", id="cct-perm-title")
+                yield Button(self._mode_badge_text(), id="cct-perm-mode-btn", tooltip="Click to cycle Security Mode (Ask / Restricted / Full)")
+                yield Static("", id="cct-perm-spacer")
+                yield Button("✕", id="cct-perm-close", classes="cct-icon-btn", tooltip="Close permissions panel (Esc)")
+
+            # 2. Body: Two organized 3D columns
+            exec_keys = {"read_files", "write_files", "execute_python", "shell_commands", "install_packages"}
+            tools_keys = {"device_control", "internet", "formula_library", "notebook", "calculator"}
+
+            with Horizontal(id="cct-perm-grid"):
+                with Vertical(classes="cct-perm-col"):
+                    yield Static("⚡ Files & Execution", classes="cct-perm-col-title")
+                    for key, label, is_on in perm.manager.snapshot():
+                        if key in exec_keys:
+                            yield PermissionRow(key, label, is_on)
+
+                with Vertical(classes="cct-perm-col"):
+                    yield Static("🌐 Network & Tools", classes="cct-perm-col-title")
+                    for key, label, is_on in perm.manager.snapshot():
+                        if key in tools_keys:
+                            yield PermissionRow(key, label, is_on)
+
+        def on_button_pressed(self, event: Button.Pressed):
+            bid = event.button.id
+            if bid == "cct-perm-close":
+                event.stop()
+                self.close_panel()
+            elif bid == "cct-perm-mode-btn":
+                event.stop()
+                modes = list(perm.MODES)
+                curr = getattr(perm.manager, "mode", "ask")
+                next_mode = modes[(modes.index(curr) + 1) % len(modes)]
+                perm.manager.set_mode(next_mode)
+                event.button.label = self._mode_badge_text()
+
+        def on_key(self, event) -> None:
+            if event.key == "escape":
+                event.stop()
+                try:
+                    event.prevent_default()
+                except Exception:
+                    pass
+                self.close_panel()
+
+        def close_panel(self):
+            self.remove_class("open")
+            if self.parent and hasattr(self.parent, "_on_permission_panel_toggled"):
+                self.parent._on_permission_panel_toggled(False)
+
+        def refresh_rows(self):
+            from . import theme_css
+            try:
+                mode_btn = self.query_one("#cct-perm-mode-btn", Button)
+                mode_btn.label = self._mode_badge_text()
+            except Exception:
+                pass
+            for key, label, is_on in perm.manager.snapshot():
+                try:
+                    toggle = self.query_one(f"#perm-toggle-{key}", Toggle3D)
+                    toggle.is_on = is_on
+                    toggle.set_class(is_on, "-on")
+                    toggle.set_class(not is_on, "-off")
+                    toggle.label = Toggle3D._format_label(is_on)
+                    row = toggle.parent
+                    if row:
+                        color = theme_css.current_hex("success" if is_on else "text-muted")
+                        mark = "●" if is_on else "○"
+                        row.query_one(".cct-perm-label", Static).update(f"[{color}]{mark}[/] {label}")
+                except Exception:
+                    pass
+
+else:
+    PermissionCard = None
+    PermissionRow = None
+    PermissionsSettingsPanel = None