code-context-control 2.28.0__py3-none-any.whl

tui/screens/session_view.py

@@ -0,0 +1,143 @@
+from datetime import datetime, timezone
+from pathlib import Path
+
+from screens.stats import Card
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Button, Log
+
+from services.activity_log import ActivityLog
+from services.session_manager import SessionManager
+
+
+class SessionView(Vertical):
+    def compose(self) -> ComposeResult:
+        with Card("Recent Sessions", ""):
+            yield Log(id="session_list_log", highlight=True)
+            yield Button("Refresh List", id="refresh_btn")
+
+        with Card("Active Session Log", ""):
+            yield Log(id="active_log", highlight=True)
+
+    def on_mount(self) -> None:
+        self.load_sessions()
+        self.set_interval(5.0, self.load_sessions)
+
+    @work(exclusive=True, thread=True)
+    def load_sessions(self) -> None:
+        project_path = Path.cwd()
+        session_mgr = SessionManager(str(project_path))
+        sessions = session_mgr.list_sessions(10)
+        current = self._current_session(project_path)
+        self.app.call_from_thread(self._render_sessions, sessions, current)
+
+    def _current_session(self, project_path: Path) -> dict | None:
+        activity = ActivityLog(str(project_path))
+        starts = activity.get_recent(limit=1, event_type="session_start")
+        if not starts:
+            return None
+        start_event = starts[0]
+        session_id = start_event.get("session_id")
+        started = start_event.get("timestamp")
+        if not session_id or not started:
+            return None
+
+        saves = activity.get_recent(limit=1, event_type="session_save")
+        if saves and saves[0].get("session_id") == session_id:
+            return None
+
+        events = activity.get_recent(limit=200, since=started)
+        tool_calls = [e for e in events if e.get("type") == "tool_call"]
+        decisions = [e for e in events if e.get("type") == "decision"]
+        files = [e for e in events if e.get("type") == "file_change"]
+        last_event = events[0] if events else start_event
+        try:
+            started_dt = datetime.fromisoformat(started)
+            duration = datetime.now(timezone.utc) - started_dt
+            duration_seconds = max(0, int(duration.total_seconds()))
+        except Exception:
+            duration_seconds = 0
+
+        return {
+            "id": session_id,
+            "started": started,
+            "description": start_event.get("description", ""),
+            "source_system": start_event.get("source_system", ""),
+            "source_ide": start_event.get("source_ide", ""),
+            "tool_calls": len(tool_calls),
+            "decisions": len(decisions),
+            "files": len(files),
+            "last_activity": last_event.get("timestamp", started),
+            "recent_events": list(reversed(events[:12])),
+            "duration": self._format_duration(duration_seconds),
+        }
+
+    def _render_sessions(self, sessions: list, current: dict | None) -> None:
+        session_log = self.query_one("#session_list_log", Log)
+        active_log = self.query_one("#active_log", Log)
+        session_log.clear()
+        active_log.clear()
+
+        if current:
+            session_log.write_line(
+                f"LIVE  {current['id']}  {current['duration']}  "
+                f"{current['tool_calls']} tools  {current['decisions']} decisions  {current['files']} files"
+            )
+            if current.get("description"):
+                session_log.write_line(f"      {current['description']}")
+            session_log.write_line("")
+            active_log.write_line(f"Session: {current['id']}")
+            active_log.write_line(f"Started: {current['started']}")
+            active_log.write_line(f"Last activity: {current['last_activity']}")
+            active_log.write_line(
+                f"Source: {current.get('source_system') or '-'} / {current.get('source_ide') or '-'}"
+            )
+            active_log.write_line(
+                f"Activity: {current['tool_calls']} tools, {current['decisions']} decisions, {current['files']} files"
+            )
+            if current.get("description"):
+                active_log.write_line(f"Description: {current['description']}")
+            active_log.write_line("")
+            active_log.write_line("Recent events:")
+            for event in current["recent_events"]:
+                label = event.get("type", "event")
+                detail = (
+                    event.get("tool")
+                    or event.get("decision")
+                    or event.get("file")
+                    or event.get("data")
+                    or ""
+                )
+                active_log.write_line(f"{event.get('timestamp', '')}  {label}  {detail}")
+        else:
+            active_log.write_line("No live session detected.")
+
+        if sessions:
+            if current:
+                session_log.write_line("Saved sessions:")
+            for session in sessions:
+                status = "DONE" if session.get("ended") else "IDLE"
+                summary = session.get("summary") or session.get("description") or ""
+                session_log.write_line(
+                    f"{status:<5} {session.get('id', '')}  "
+                    f"{session.get('duration') or '-':<8}  "
+                    f"{session.get('tool_calls', 0)} tools  "
+                    f"{summary[:80]}"
+                )
+        elif not current:
+            session_log.write_line("No session history found.")
+
+    @staticmethod
+    def _format_duration(seconds: int) -> str:
+        if seconds < 60:
+            return f"{seconds}s"
+        minutes, secs = divmod(seconds, 60)
+        if minutes < 60:
+            return f"{minutes}m {secs}s" if secs else f"{minutes}m"
+        hours, mins = divmod(minutes, 60)
+        return f"{hours}h {mins}m" if mins else f"{hours}h"
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "refresh_btn":
+            self.load_sessions()

tui/screens/stats.py

@@ -0,0 +1,158 @@
+import os
+import socket
+import sys
+import webbrowser
+
+from backend import get_c3_path
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Button, DataTable, Label, Static
+
+
+class Card(Vertical):
+    def __init__(self, title: str, content: str, **kwargs):
+        super().__init__(**kwargs)
+        self.card_title = title
+        self.card_content = content
+        self.add_class("card")
+
+    def compose(self) -> ComposeResult:
+        yield Label(self.card_title, classes="card-title")
+        if self.card_content:
+            yield Static(self.card_content)
+
+class StatsWidget(Vertical):
+    def compose(self) -> ComposeResult:
+        with Card("Quick Actions", ""):
+            yield Button("Project Init", id="quick_init_btn", variant="primary", classes="quick-btn")
+            yield Button("MCP Install", id="quick_mcp_btn", variant="primary", classes="quick-btn")
+            yield Button("Refresh Stats", id="refresh_stats_btn", classes="quick-btn")
+
+        yield Label("System Metrics", classes="card-title")
+        yield DataTable(id="stats-table")
+        yield Button("Web UI Status: Checking...", id="web_ui_status_btn", classes="ui-btn-offline")
+        yield Button("Terminate UI", id="terminate_ui_btn", variant="error", classes="quick-btn")
+
+    def on_mount(self) -> None:
+        table = self.query_one("#stats-table", DataTable)
+        table.add_columns("Component", "Metric", "Value")
+        table.cursor_type = "row"
+        table.zebra_stripes = True
+
+        self.query_one("#terminate_ui_btn").display = False
+
+        self.load_stats()
+        self.check_ui_status()
+        self.set_interval(5.0, self.check_ui_status)
+
+    @work(exclusive=True, thread=True)
+    def check_ui_status(self) -> None:
+        port = 3333
+        is_open = False
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.settimeout(0.5)
+            is_open = (s.connect_ex(('localhost', port)) == 0)
+
+        self.app.call_from_thread(self._update_ui_btn, is_open, port)
+
+    def _update_ui_btn(self, is_open: bool, port: int) -> None:
+        btn = self.query_one("#web_ui_status_btn", Button)
+        term_btn = self.query_one("#terminate_ui_btn", Button)
+        if is_open:
+            btn.label = f"Web UI: Running (Port {port})"
+            btn.remove_class("ui-btn-offline")
+            btn.add_class("ui-btn-online")
+            term_btn.display = True
+            self._current_ui_url = f"http://localhost:{port}"
+        else:
+            btn.label = "Web UI: Offline"
+            btn.remove_class("ui-btn-online")
+            btn.add_class("ui-btn-offline")
+            term_btn.display = False
+            self._current_ui_url = None
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "web_ui_status_btn" and getattr(self, "_current_ui_url", None):
+            webbrowser.open(self._current_ui_url)
+        elif event.button.id == "terminate_ui_btn":
+            self.terminate_web_ui()
+        elif event.button.id == "refresh_stats_btn":
+            table = self.query_one("#stats-table", DataTable)
+            table.clear()
+            self.load_stats()
+        elif event.button.id == "quick_init_btn":
+            self.app.mount_view("init", "Init")
+            self.app.query_one("#nav_list").index = 9
+        elif event.button.id == "quick_mcp_btn":
+            self.app.mount_view("mcp", "MCP")
+            self.app.query_one("#nav_list").index = 10
+
+    @work(exclusive=True, thread=True)
+    def terminate_web_ui(self) -> None:
+        port = 3333
+        try:
+            import subprocess
+            kwargs = {}
+            if sys.platform == "win32":
+                kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+            if sys.platform == "win32":
+                result = subprocess.run(f"netstat -ano | findstr :{port}", shell=True, capture_output=True, text=True, **kwargs)
+                lines = result.stdout.strip().split('\n')
+                pids = set()
+                for line in lines:
+                    if f":{port}" in line and "LISTENING" in line:
+                        parts = line.strip().split()
+                        if len(parts) >= 5:
+                            pids.add(parts[-1])
+                for pid in pids:
+                    subprocess.run(f"taskkill /PID {pid} /F", shell=True, capture_output=True, **kwargs)
+            else:
+                subprocess.run(f"lsof -ti:{port} | xargs kill -9", shell=True, capture_output=True)
+            self.check_ui_status()
+        except Exception:
+            pass
+
+    @work(exclusive=True, thread=True)
+    def load_stats(self) -> None:
+        try:
+            import subprocess
+            c3_path, root_dir = get_c3_path()
+            env = os.environ.copy()
+            env["PYTHONPATH"] = root_dir
+            env["NO_COLOR"] = "1"
+            env["TERM"] = "dumb"
+
+            kwargs = {}
+            if sys.platform == "win32":
+                kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+
+            result = subprocess.run(
+                [sys.executable, c3_path, "stats"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                env=env,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                **kwargs
+            )
+            self.app.call_from_thread(self._render_stats, result.stdout)
+        except Exception:
+            pass
+
+    def _render_stats(self, output: str) -> None:
+        try:
+            table = self.query_one("#stats-table", DataTable)
+            table.clear()
+
+            for line in output.splitlines():
+                if not line.strip() or line.startswith("+") or line.startswith("System") or "C3 Statistics" in line:
+                    continue
+                parts = [p.strip() for p in line.split("|")]
+                parts = [p for p in parts if p] # Remove empty splits
+
+                if len(parts) >= 3 and parts[0] != "Component" and not parts[0].startswith("-"):
+                    table.add_row(parts[0], parts[1], parts[2])
+        except Exception:
+            pass

tui/screens/ui_view.py

@@ -0,0 +1,54 @@
+import asyncio
+import os
+import sys
+
+from backend import get_c3_path
+from screens.stats import Card
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Button, Checkbox, Input, Label, Log
+
+
+class UIView(Vertical):
+    def compose(self) -> ComposeResult:
+        with Card("Web Dashboard Control", ""):
+            with Horizontal(classes="input-row"):
+                yield Label("Port: ", classes="input-label")
+                yield Input("3333", id="port_input")
+            with Horizontal(classes="input-row"):
+                yield Checkbox("Nano Mode", id="nano_check")
+            with Horizontal(classes="action-row"):
+                yield Button("Launch Web UI", id="run_btn", variant="primary")
+
+        with Card("Server Status", ""):
+            yield Log(id="output_log", highlight=True)
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "run_btn":
+            port = self.query_one("#port_input").value or "3333"
+            nano = self.query_one("#nano_check").value
+            self.query_one("#output_log").clear()
+            self.launch_ui(port, nano)
+
+    @work(exclusive=True)
+    async def launch_ui(self, port: str, nano: bool) -> None:
+        c3_path, root_dir = get_c3_path()
+        args = ["ui", "--port", port]
+        if nano: args.append("--nano")
+        args.append("--no-browser") # TUI handle manually or just show URL
+
+        cmd = [sys.executable, c3_path] + args
+        env = os.environ.copy()
+        env["PYTHONPATH"] = root_dir
+
+        log_widget = self.query_one("#output_log")
+        log_widget.write_line(f"Starting Web UI on http://localhost:{port}...")
+
+        # We don't wait for this one to finish as it's a server
+        process = await asyncio.create_subprocess_exec(*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.STDOUT, env=env)
+
+        while True:
+            line = await process.stdout.readline()
+            if not line: break
+            log_widget.write_line(line.decode(errors="replace").rstrip())

tui/theme.tcss

@@ -0,0 +1,335 @@
+Screen.theme-dark {
+    background: #2E3440;
+    color: #ECEFF4;
+}
+
+Screen.theme-light {
+    background: #F4F1EA;
+    color: #2A2118;
+}
+
+Screen.theme-dark #sidebar {
+    width: 20;
+    dock: left;
+    height: 100%;
+    background: #242933;
+    border-right: solid #3B4252;
+}
+
+Screen.theme-light #sidebar {
+    width: 20;
+    dock: left;
+    height: 100%;
+    background: #E8E1D5;
+    border-right: solid #C9B9A3;
+}
+
+#nav_list {
+    background: transparent;
+    border: none;
+}
+
+#nav_list > ListItem {
+    padding: 0 1;
+    background: transparent;
+}
+
+Screen.theme-dark #nav_list > ListItem:hover {
+    background: #3B4252;
+}
+
+Screen.theme-light #nav_list > ListItem:hover {
+    background: #D5C9B8;
+}
+
+Screen.theme-dark #nav_list > ListItem.-active {
+    background: #434C5E;
+    color: #88C0D0;
+    text-style: bold;
+}
+
+Screen.theme-light #nav_list > ListItem.-active {
+    background: #C4B29A;
+    color: #0F766E;
+    text-style: bold;
+}
+
+#content {
+    width: 100%;
+    height: 100%;
+    padding: 0 1;
+    overflow-y: auto;
+}
+
+Screen.theme-dark .card {
+    border: solid #3B4252;
+    padding: 0 1;
+    margin-bottom: 0;
+    background: #2E3440;
+}
+
+Screen.theme-light .card {
+    border: solid #C9B9A3;
+    padding: 0 1;
+    margin-bottom: 0;
+    background: #F4F1EA;
+}
+
+Screen.theme-dark .card-title {
+    color: #88C0D0;
+    text-style: bold;
+    margin-bottom: 0;
+}
+
+Screen.theme-light .card-title {
+    color: #0F766E;
+    text-style: bold;
+    margin-bottom: 0;
+}
+
+Screen.theme-dark Header {
+    background: #242933;
+    color: #88C0D0;
+}
+
+Screen.theme-light Header {
+    background: #E8E1D5;
+    color: #0F766E;
+}
+
+Screen.theme-dark Footer {
+    background: #242933;
+    color: #4C566A;
+}
+
+Screen.theme-light Footer {
+    background: #E8E1D5;
+    color: #756250;
+}
+
+Screen.theme-dark Footer > .footer--key {
+    color: #88C0D0;
+    text-style: bold;
+}
+
+Screen.theme-light Footer > .footer--key {
+    color: #0F766E;
+    text-style: bold;
+}
+
+Screen.theme-dark LoadingIndicator {
+    color: #88C0D0;
+}
+
+Screen.theme-light LoadingIndicator {
+    color: #0F766E;
+}
+
+.input-row { height: auto; min-height: 1; margin-bottom: 1; }
+.action-row { height: 1; margin-bottom: 1; }
+#index-config-row { height: 1; margin-bottom: 1; }
+#index-actions-row { height: 1; margin-bottom: 1; }
+
+.input-label { padding-top: 0; margin-right: 1; }
+
+Screen.theme-dark Input {
+    width: 20;
+    background: #3B4252;
+    border: none;
+    height: 1;
+    min-height: 1;
+    padding: 0 1;
+    color: #ECEFF4;
+}
+
+Screen.theme-light Input {
+    width: 20;
+    background: #D5C9B8;
+    border: none;
+    height: 1;
+    min-height: 1;
+    padding: 0 1;
+    color: #2A2118;
+}
+
+Screen.theme-dark Input:focus {
+    background: #434C5E;
+    color: #88C0D0;
+}
+
+Screen.theme-light Input:focus {
+    background: #C4B29A;
+    color: #0F766E;
+}
+
+Screen.theme-dark Button {
+    margin-right: 2;
+    border: none;
+    height: 1;
+    min-height: 1;
+    padding: 0 1;
+    background: #3B4252;
+    color: #ECEFF4;
+}
+
+Screen.theme-light Button {
+    margin-right: 2;
+    border: none;
+    height: 1;
+    min-height: 1;
+    padding: 0 1;
+    background: #D5C9B8;
+    color: #2A2118;
+}
+
+Screen.theme-dark Button.-primary {
+    background: #88C0D0;
+    color: #2E3440;
+}
+
+Screen.theme-light Button.-primary {
+    background: #0F766E;
+    color: #F4F1EA;
+}
+
+Screen.theme-dark Button.-error {
+    background: #BF616A;
+    color: #ECEFF4;
+}
+
+Screen.theme-light Button.-error {
+    background: #B42318;
+    color: #F4F1EA;
+}
+
+Screen.theme-dark Log {
+    height: 100%;
+    border: none;
+    background: #242933;
+    margin-top: 0;
+}
+
+Screen.theme-light Log {
+    height: 100%;
+    border: none;
+    background: #E8E1D5;
+    margin-top: 0;
+}
+
+Checkbox { height: 1; min-height: 1; border: none; padding: 0; margin-right: 2; }
+Checkbox > .toggle--label { padding-left: 1; }
+Checkbox:focus { background: transparent; }
+
+Screen.theme-dark #cwd_label {
+    dock: bottom;
+    text-align: right;
+    width: 100%;
+    color: #88C0D0;
+    background: transparent;
+}
+
+Screen.theme-light #cwd_label {
+    dock: bottom;
+    text-align: right;
+    width: 100%;
+    color: #0F766E;
+    background: transparent;
+}
+
+Screen.theme-dark #right-sidebar {
+    width: 35;
+    dock: right;
+    height: 100%;
+    background: #242933;
+    border-left: solid #3B4252;
+    padding: 1;
+}
+
+Screen.theme-light #right-sidebar {
+    width: 35;
+    dock: right;
+    height: 100%;
+    background: #E8E1D5;
+    border-left: solid #C9B9A3;
+    padding: 1;
+}
+
+Screen.theme-dark .info-text {
+    color: #6B7280;
+    margin-bottom: 1;
+    text-style: italic;
+}
+
+Screen.theme-light .info-text {
+    color: #756250;
+    margin-bottom: 1;
+    text-style: italic;
+}
+
+#web_ui_status_btn { width: 100%; margin-top: 1; text-align: center; }
+
+Screen.theme-dark .ui-btn-online { background: #A3BE8C; color: #2E3440; }
+Screen.theme-light .ui-btn-online { background: #4D7C0F; color: #F4F1EA; }
+Screen.theme-dark .ui-btn-offline { background: #4C566A; color: #ECEFF4; }
+Screen.theme-light .ui-btn-offline { background: #756250; color: #F4F1EA; }
+
+.quick-btn { width: 100%; margin-bottom: 1; text-align: center; }
+
+.proj-add-row { height: auto; min-height: 1; margin-bottom: 1; }
+.proj-toolbar-row { height: auto; min-height: 1; margin-bottom: 1; }
+.proj-action-row { height: 1; margin-bottom: 1; }
+.proj-path-input { width: 40; }
+.proj-name-input { width: 20; }
+
+DataTable { height: 1fr; }
+
+Screen.theme-dark DataTable > .datatable--header {
+    color: #88C0D0;
+    text-style: bold;
+}
+
+Screen.theme-light DataTable > .datatable--header {
+    color: #0F766E;
+    text-style: bold;
+}
+
+Screen.theme-dark DataTable > .datatable--cursor {
+    background: #434C5E;
+    color: #ECEFF4;
+}
+
+Screen.theme-light DataTable > .datatable--cursor {
+    background: #C4B29A;
+    color: #2A2118;
+}
+
+#projects_grid {
+    height: auto;
+    display: none;
+}
+
+.project-grid-row {
+    height: auto;
+    min-height: 7;
+    margin-bottom: 1;
+}
+
+.project-card {
+    width: 1fr;
+    height: auto;
+    min-height: 7;
+    margin-right: 1;
+    content-align: left top;
+    text-align: left;
+    padding: 1 2;
+}
+
+Screen.theme-dark .projects-empty-state {
+    padding: 1 0;
+    color: #6B7280;
+}
+
+Screen.theme-light .projects-empty-state {
+    padding: 1 0;
+    color: #756250;
+}