cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/ui/activity_panel.py

@@ -0,0 +1,231 @@
+"""
+CCT UI — ActivityPanel (v0.7.8.1 Live Thinking panel).
+
+A small live popup (Ctrl+T) showing the state of the turn currently
+in flight — the "live thinking" surface the spec asks for:
+
+  spinner + stage ......... live (thinking.detect_stage, same engine
+                            as the composer's status bar)
+  elapsed timer ........... live
+  tokens streamed ......... live chunk counter from the worker
+  files touched ........... agent/pipeline tool steps with a path
+  last tool step .......... most recent agent tool (name + target)
+  provider / model ........ from aicore config
+  session usage ........... requests + total tokens (aicore)
+
+It never pokes widget internals: CCTApp._activity is a plain dict of
+counters the workers bump (see _stream_worker / _pipeline_worker),
+and the stage/timer recomputation reads the composer's streaming
+state through tiny defensive getters. When nothing is running it
+reports "idle" honestly instead of faking activity.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+import time
+
+TEXTUAL_AVAILABLE = True
+try:
+    from textual.screen import Screen
+    from textual.containers import Vertical, Horizontal
+    from textual.widgets import Static, Button
+    from textual.binding import Binding
+except Exception:
+    TEXTUAL_AVAILABLE = False
+
+if TEXTUAL_AVAILABLE:
+    from . import thinking
+    from . import theme_css
+
+
+    class ActivityPanel(Screen):
+        """Live activity popup for the in-flight turn (Ctrl+T)."""
+
+        CSS = """
+        ActivityPanel { align: center middle; background: $app-background 70%; }
+        #act-box {
+            width: 62; height: auto; max-height: 90%;
+            background: $surface; border: round $border; padding: 0;
+            opacity: 0; offset-y: 1;
+            transition: opacity 150ms, offset 180ms;
+        }
+        #act-box.open { opacity: 1; offset-y: 0; }
+        #act-titlebar { height: 3; padding: 1 2 0 2; border-bottom: solid $border; }
+        #act-title { text-style: bold; width: 1fr; }
+        #act-body { padding: 1 2; overflow-y: auto; }
+        #act-stage { height: 1; }
+        #act-stats { height: 8; padding-top: 1; color: $text-muted; }
+        #act-usage { height: 2; padding-top: 1; color: $text-faint; }
+        #act-actions { height: 5; padding: 0 2 1 2; border-top: solid $border; }
+        #act-actions Button { margin-right: 1; }
+        .act-hint { color: $text-faint; padding: 0 2 1 2; }
+        """
+
+        BINDINGS = [Binding("escape", "cancel", "Cancel")]
+
+        def __init__(self):
+            super().__init__()
+            self._spin_tick = 0
+
+        def compose(self):
+            with Vertical(id="act-box"):
+                with Horizontal(id="act-titlebar"):
+                    yield Static("\U0001f9e0  Live Activity", id="act-title")
+                    yield Button("\u2715", id="act-close", classes="cct-popup-close")
+                with Vertical(id="act-body"):
+                    yield Static("", id="act-stage")
+                    yield Static("", id="act-stats")
+                    yield Static("", id="act-usage")
+                with Horizontal(id="act-actions"):
+                    yield Button("\u23f9 Stop", id="act-stop", variant="error", classes="cct-btn")
+                    yield Button("Close", id="act-close-btn", classes="cct-btn")
+                yield Static("Esc to close", classes="act-hint")
+
+        def on_mount(self):
+            self.call_after_refresh(lambda: self.query_one("#act-box").add_class("open"))
+            self.call_after_refresh(self._fit)
+            # Cache the activity module once at mount, not every 100ms tick
+            try:
+                from .. import activity as _act_mod
+                self._act_mod = _act_mod
+            except Exception:
+                self._act_mod = None
+            self._timer = self.set_interval(0.1, self._refresh)
+
+        def on_unmount(self):
+            # Mirror ActivityStreamPanel: the 100ms refresh ticker is
+            # owned by this screen and must stop when it closes.
+            try:
+                if getattr(self, "_timer", None) is not None:
+                    self._timer.stop()
+            except Exception:
+                pass
+            self._timer = None
+
+        def on_resize(self, event):
+            self._fit()
+
+        def _fit(self):
+            try:
+                self.call_after_refresh(
+                    lambda: theme_css.fit_dialog(self, "act-box", "act-body"))
+            except Exception:
+                pass
+
+        def _refresh(self):
+            try:
+                self._spin_tick += 1
+                app = self.app
+                streaming = bool(getattr(app, "_is_streaming", False))
+                # ── REAL activity: single source of truth ──
+                _act = self._act_mod
+                if _act is not None:
+                    tid = getattr(app, "_streaming_turn_id", None) or getattr(app.composer, "_stream_turn_id", None)
+                    acts = _act.manager.get_for_turn(tid) if tid else []
+                    running = [a for a in acts if a.status in (_act.RUNNING, _act.PENDING, _act.WAITING)]
+                    target = running[-1] if running else (acts[-1] if acts else None)
+                    if target:
+                        # real data
+                        elapsed = target.elapsed_time
+                        # spinner by status
+                        if target.status == _act.RUNNING:
+                            spin = ["⠋","⠙","⠹","⠸","⠼","⠴","⠦","⠧","⠇","⠏"][self._spin_tick % 10]
+                            color = theme_css.current_hex("accent")
+                        elif target.status == _act.WAITING:
+                            spin = "?"
+                            color = theme_css.current_hex("warning")
+                        elif target.status == _act.FAILED:
+                            spin = "✕"
+                            color = theme_css.current_hex("error")
+                        elif target.status == _act.COMPLETED:
+                            spin = "✓"
+                            color = theme_css.current_hex("success")
+                        else:
+                            spin = "●"
+                            color = theme_css.current_hex("text-faint")
+                        title = target.title or target.current_step or "Working"
+                        prov = f"{target.provider} {target.model}".strip() or f"{target.provider or ''} {target.model or ''}".strip()
+                        if not prov:
+                            try:
+                                from .. import aicore as _ac
+                                cfg = _ac.load_config()
+                                prov = f"{(cfg.get('provider') or '').upper()} {cfg.get('model') or ''}".strip()
+                            except Exception:
+                                prov = "—"
+                        stage_box = self.query_one("#act-stage", Static)
+                        stage_box.update(f"[{color}]{spin}[/] [{color}]{title}[/]  ·  [{color}]{target.status}[/]  ·  {target.elapsed_time:.1f}s")
+                        # stats from real activity
+                        lines = [
+                            f"  [{theme_css.current_hex('text-faint')}]elapsed[/]      {target.elapsed_time:.1f}s",
+                            f"  [{theme_css.current_hex('text-faint')}]status[/]       {target.status}",
+                            f"  [{theme_css.current_hex('text-faint')}]provider[/]    {prov or '—'}",
+                            f"  [{theme_css.current_hex('text-faint')}]progress[/]    {int((target.progress or 0)*100)}%" if target.progress is not None else f"  [{theme_css.current_hex('text-faint')}]progress[/]    —",
+                            f"  [{theme_css.current_hex('text-faint')}]workspace[/]   {target.workspace or '—'}",
+                        ]
+                        if target.file:
+                            lines.append(f"  [{theme_css.current_hex('text-faint')}]file[/]         {target.file}")
+                        if target.command:
+                            lines.append(f"  [{theme_css.current_hex('text-faint')}]command[/]      {target.command[:40]}")
+                        if target.error:
+                            lines.append(f"  [{theme_css.current_hex('text-faint')}]error[/]        {target.error[:60]}")
+                        stats_box = self.query_one("#act-stats", Static)
+                        stats_box.update("\n".join(lines))
+                        # usage
+                        try:
+                            from .. import aicore
+                            usage = aicore.get_session_usage()
+                        except Exception:
+                            usage = {}
+                        usage_box = self.query_one("#act-usage", Static)
+                        if isinstance(usage, dict):
+                            usage_box.update(
+                                "  session: "
+                                f"{usage.get('requests', 0)} requests · "
+                                f"{usage.get('prompt_tokens', 0)} prompt · "
+                                f"{usage.get('completion_tokens', 0)} completion · "
+                                f"{usage.get('total_tokens', 0)} total")
+                        stop_btn = self.query_one("#act-stop", Button)
+                        stop_btn.display = streaming and target.cancellable
+                        return
+                # fallback: no real activity -> idle (never fake)
+                stage_box = self.query_one("#act-stage", Static)
+                stats_box = self.query_one("#act-stats", Static)
+                usage_box = self.query_one("#act-usage", Static)
+                stop_btn = self.query_one("#act-stop", Button)
+                stop_btn.display = streaming
+                if not streaming:
+                    stage_box.update(f"[{theme_css.current_hex('text-faint')}]⎺ Idle — no turn in flight[/]")
+                    stats_box.update(f"  [{theme_css.current_hex('text-faint')}]No active tasks[/]\n  start a message to watch it live.")
+                    usage_box.update("")
+                else:
+                    # streaming but no activity yet -> minimal real spinner
+                    spin = ["⠋","⠙","⠹","⠸","⠼","⠴","⠦","⠧","⠇","⠏"][self._spin_tick % 10]
+                    color = theme_css.current_hex("accent")
+                    stage_box.update(f"[{color}]{spin}[/] [{color}]Working…[/]  ·  {time.time() - (getattr(app, '_activity', {}).get('start') or time.time()):.1f}s")
+                    stats_box.update("  preparing real activity…")
+                    usage_box.update("")
+            except Exception:
+                pass
+
+        def action_cancel(self):
+            self.dismiss(None)
+
+        def on_button_pressed(self, event):
+            eid = event.button.id
+            if eid in ("act-close", "act-close-btn"):
+                self.dismiss(None)
+            elif eid == "act-stop":
+                try:
+                    self.app.action_cancel_streaming()
+                except Exception:
+                    pass
+
+        def on_key(self, event):
+            if event.key == "escape":
+                self.dismiss(None)
+
+else:
+    ActivityPanel = None

calc_terminal/ui/activity_stream_panel.py

@@ -0,0 +1,238 @@
+"""
+CCT UI — activity_stream_panel.py: Activity Stream panel (v0.7.6).
+A Textual-based embedded panel that shows real-time tool execution
+activity from the event_stream. Displays a live-scrolling list of
+recent events with timestamps, icons, and color-coded status.
+
+Each event is formatted with:
+  - Human-readable timestamp
+  - Event-type icon/label
+  - Short description from event data
+  - Color: green (success), red (failure), yellow (in-progress)
+
+Auto-refreshes every 2 seconds via a Textual timer. Max 50 visible
+items in a scrollable container.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+import datetime
+import time
+
+TEXTUAL_AVAILABLE = True
+try:
+    from textual.containers import Vertical, ScrollView
+    from textual.widgets import Static
+except Exception:
+    TEXTUAL_AVAILABLE = False
+
+if TEXTUAL_AVAILABLE:
+    from . import theme_css
+    from .. import event_stream as _event_stream_mod
+
+
+    _EVENT_ICONS = {
+        _event_stream_mod.TOOL_STARTED:      ("\U0001f527", "[TOOL]",       "yellow"),
+        _event_stream_mod.TOOL_RESULT:       ("\u2705",    "[DONE]",       "green"),
+        _event_stream_mod.FILE_CREATED:      ("\u2795",    "[CREATE]",     "green"),
+        _event_stream_mod.FILE_EDITED:       ("\u270f\ufe0f", "[EDIT]",     "yellow"),
+        _event_stream_mod.FILE_DELETED:      ("\u2716\ufe0f", "[DELETE]",   "red"),
+        _event_stream_mod.FILE_MOVED:        ("\u2b05\ufe0f", "[MOVE]",     "yellow"),
+        _event_stream_mod.COMMAND_STARTED:   ("\u25b6\ufe0f", "[CMD]",      "yellow"),
+        _event_stream_mod.COMMAND_RESULT:    ("\u2714\ufe0f", "[CMD_DONE]", "green"),
+        _event_stream_mod.AGENT_STARTED:     ("\U0001f916", "[AGENT]",      "yellow"),
+        _event_stream_mod.AGENT_COMPLETED:   ("\U0001f3c6", "[AGENT_DONE]", "green"),
+        _event_stream_mod.AGENT_FAILED:      ("\u274c",    "[AGENT_FAIL]", "red"),
+        _event_stream_mod.MEMORY_CREATED:    ("\U0001f4be", "[MEM]",       "green"),
+        _event_stream_mod.MEMORY_UPDATED:    ("\U0001f504", "[MEM_UPD]",   "yellow"),
+        _event_stream_mod.MEMORY_DELETED:    ("\U0001f5d1\ufe0f", "[MEM_DEL]", "red"),
+        _event_stream_mod.MEMORY_READ:       ("\U0001f4d6", "[MEM_READ]",  "text-muted"),
+        _event_stream_mod.MODEL_RESPONSE:    ("\U0001f4ac", "[RESP]",      "text-muted"),
+        _event_stream_mod.TOOL_REQUEST:      ("\U0001f4e1", "[REQ]",       "yellow"),
+        _event_stream_mod.SESSION_CLEARED:   ("\U0001f5d1\ufe0f", "[CLEAR]", "red"),
+        _event_stream_mod.CONTEXT_SWITCHED:  ("\U0001f504", "[CTX]",       "yellow"),
+    }
+
+    _MAX_VISIBLE = 50
+
+
+    def _fmt_ts(ts):
+        """Format a UNIX timestamp into a short human-readable string."""
+        try:
+            dt = datetime.datetime.fromtimestamp(ts)
+            now = datetime.datetime.now()
+            if dt.date() == now.date():
+                return dt.strftime("%H:%M:%S")
+            return dt.strftime("%m-%d %H:%M")
+        except Exception:
+            return "??:??:??"
+
+
+    class ActivityStreamPanel(Static):
+        """Embedded activity stream widget — mount this inside a
+        layout to get a live scrolling feed of event_stream events."""
+
+        CSS = """
+        ActivityStreamPanel {
+            height: 1fr;
+            width: 1fr;
+            background: $surface;
+            border: round $border;
+            padding: 0;
+            overflow: hidden;
+        }
+        #as-header {
+            height: 1;
+            padding: 0 1;
+            border-bottom: solid $border;
+            background: $surface-alt;
+        }
+        #as-header Label {
+            text-style: bold;
+        }
+        #as-body {
+            height: 1fr;
+            overflow-y: auto;
+            padding: 0 1;
+        }
+        .as-event {
+            height: auto;
+            min-height: 1;
+            padding: 0 0;
+            width: 1fr;
+        }
+        .as-event:hover {
+            background: $surface-alt;
+        }
+        #as-empty {
+            height: 3;
+            padding: 1 0;
+            color: $text-faint;
+            text-align: center;
+        }
+        #as-footer {
+            height: 1;
+            padding: 0 1;
+            border-top: solid $border;
+            color: $text-faint;
+        }
+        """
+
+        def __init__(self, **kwargs):
+            super().__init__(**kwargs)
+            self._refresh_timer = None
+            self._last_count = 0
+
+        def compose(self):
+            with Vertical(id="as-stream-wrap"):
+                yield Static(" \U0001f4ca  Activity Stream", id="as-header")
+                yield ScrollView(id="as-body")
+                yield Static("", id="as-footer")
+
+        def on_mount(self):
+            from .. import event_stream
+            self._event_stream = event_stream.stream
+            self._refresh_timer = self.set_interval(2.0, self.refresh_stream)
+            self.refresh_stream()
+
+        def on_unmount(self):
+            if self._refresh_timer is not None:
+                self._refresh_timer.stop()
+                self._refresh_timer = None
+
+        def refresh_stream(self):
+            """Poll recent events from event_stream and update the display."""
+            try:
+                from .. import event_stream
+                events = event_stream.stream.get_recent(limit=_MAX_VISIBLE)
+            except Exception:
+                return
+
+            if not events:
+                try:
+                    body = self.query_one("#as-body", ScrollView)
+                    if not body.children:
+                        body.mount(
+                            Static("No activity yet.", id="as-empty"))
+                except Exception:
+                    pass
+                return
+
+            if len(events) == self._last_count:
+                return
+            self._last_count = len(events)
+
+            try:
+                body = self.query_one("#as-body", ScrollView)
+            except Exception:
+                return
+
+            for child in list(body.children):
+                child.remove()
+
+            for ev in reversed(events[-_MAX_VISIBLE:]):
+                body.mount(Static(self._format_event(ev), classes="as-event"))
+
+            try:
+                footer = self.query_one("#as-footer", Static)
+                footer.update(f"  {len(events)} event{'s' if len(events) != 1 else ''}")
+            except Exception:
+                pass
+
+            try:
+                body.scroll_end(animate=False)
+            except Exception:
+                pass
+
+        def _format_event(self, ev):
+            """Format a single event as a Rich-markup string."""
+            icon_tuple = _EVENT_ICONS.get(
+                ev.event_type, ("\u2753", f"[{ev.event_type}]", "text-muted"))
+            emoji, label, color = icon_tuple
+
+            ts_str = _fmt_ts(ev.timestamp)
+
+            desc = ev.data.get("description", "")
+            if not desc:
+                path = ev.data.get("path") or ev.data.get("file", "")
+                tool = ev.data.get("tool", "")
+                cmd = ev.data.get("command", "")
+                agent = ev.data.get("agent", "")
+                if path:
+                    desc = str(path)
+                elif tool:
+                    desc = str(tool)
+                elif cmd:
+                    desc = str(cmd)[:40]
+                elif agent:
+                    desc = str(agent)
+                else:
+                    desc = ev.event_type
+
+            try:
+                hex_color = theme_css.current_hex(color)
+            except Exception:
+                hex_color = theme_css.current_hex("text-muted")
+
+            return (
+                f"[{hex_color}]{ts_str}[/]  "
+                f"[{hex_color}]{emoji}[/]  "
+                f"[{hex_color}]{desc}[/]"
+            )
+
+        def clear(self):
+            """Clear the displayed event list."""
+            try:
+                body = self.query_one("#as-body", ScrollView)
+                for child in list(body.children):
+                    child.remove()
+                body.mount(Static("Stream cleared.", id="as-empty"))
+            except Exception:
+                pass
+            self._last_count = 0
+
+else:
+    ActivityStreamPanel = None

calc_terminal/ui/animations.py

@@ -0,0 +1,122 @@
+"""
+CCT UI — animations.py (spec v0.7 project structure list).
+
+The v0.7 spec asks for a `ui/animations.py` file with Thinking/
+Searching/Responding indicators and live elapsed time. That engine
+already existed and already matched the spec exactly — see
+thinking.py's docstring ("Advanced AI Response Animation System",
+spec item #25) — just under a different filename, wired into
+composer.py's live status row and conversation.py's completion
+summary.
+
+Per the v0.7 brief ("Do NOT rewrite working modules"), this file does
+not reimplement that logic a second time. It re-exports thinking.py's
+public surface under the name the new architecture list expects, and
+adds one small piece that genuinely didn't exist yet: an `AnimatedTick`
+helper Textual widgets can use to self-drive a spinner + elapsed-timer
+label without each caller hand-rolling its own `set_interval` bookkeeping.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+import time
+
+from .thinking import (  # noqa: F401  (re-exported, not unused)
+    DOT_FRAMES, BRAILLE_FRAMES, BLOCK_FRAMES, STYLES,
+    STAGES, DEFAULT_STAGE, IDLE_ICONS,
+    spinner_frame, detect_stage, stage_info, format_timer,
+    idle_icon, commands_used, completion_summary_lines,
+)
+
+TEXTUAL_AVAILABLE = True
+try:
+    from textual.widgets import Static
+except Exception:
+    TEXTUAL_AVAILABLE = False
+
+
+if TEXTUAL_AVAILABLE:
+
+    class AnimatedTick(Static):
+        """A self-driving `<spinner frame> <Stage Label> <elapsed>s`
+        line — Thinking / Searching / Responding, matching the spec's
+        three named animation styles via thinking.stage_info()'s style
+        field. Callers set the stage with `set_stage(key, prompt=...)`;
+        this widget owns its own interval and elapsed-time math so nothing
+        else has to poll it.
+        """
+
+        def __init__(self, stage=DEFAULT_STAGE, id=None):
+            super().__init__("", id=id, classes="cct-animated-tick")
+            self._stage = stage
+            self._tick = 0
+            self._started = time.time()
+            self._chunk_count = 0
+            self._running = False
+            self._interval = None
+
+        def on_mount(self):
+            self._redraw()
+
+        def on_unmount(self):
+            self.stop()
+
+        def start(self, stage=None):
+            self._started = time.time()
+            self._chunk_count = 0
+            self._tick = 0
+            if stage:
+                self._stage = stage
+            self._running = True
+            self._redraw()
+            # Never stack a second 8Hz ticker on repeated start():
+            # stop the previous interval first (mirrors cat_agent's
+            # duplicate guard).
+            try:
+                if self._interval is not None:
+                    self._interval.stop()
+            except Exception:
+                pass
+            self._interval = self.set_interval(1 / 8, self._on_tick)
+
+        def stop(self):
+            self._running = False
+            try:
+                if self._interval is not None:
+                    self._interval.stop()
+            except Exception:
+                pass
+            self._interval = None
+
+        def note_chunk(self):
+            """Call once per streamed chunk so elapsed-time-based stage
+            progression (thinking.detect_stage) can tell 'still waiting
+            for the first token' from 'tokens are already arriving'."""
+            self._chunk_count += 1
+
+        def set_stage(self, stage_key):
+            self._stage = stage_key
+            self._redraw()
+
+        def elapsed(self):
+            return time.time() - self._started
+
+        def _on_tick(self):
+            self._tick += 1
+            self._redraw()
+
+        def _redraw(self):
+            label, color, style = stage_info(self._stage)
+            frame = spinner_frame(style, self._tick)
+            elapsed_txt = format_timer(self.elapsed()) if self._running else ""
+            text = f"[{color}]{frame} {label}"
+            if elapsed_txt:
+                text += f"  {elapsed_txt}"
+            text += "[/]"
+            self.update(text)
+
+else:
+    AnimatedTick = None