claudechic 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

claudechic/profiling.py

@@ -9,6 +9,7 @@ from contextlib import contextmanager
 
 _enabled = os.environ.get("CHIC_PROFILE", "true").lower() != "false"
 _stats: dict[str, dict] = defaultdict(lambda: {"count": 0, "total": 0.0, "max": 0.0})
+_start_time = time.perf_counter()
 
 
 @contextmanager
@@ -60,7 +61,15 @@ def get_stats_table():
     """Get statistics as a Rich Table (borderless, compact)."""
     from rich.table import Table
 
-    table = Table(box=None, padding=(0, 4), collapse_padding=True, show_header=True)
+    duration = get_session_duration()
+    table = Table(
+        box=None,
+        padding=(0, 4),
+        collapse_padding=True,
+        show_header=True,
+        title=f"[dim]Session duration: {duration:.1f}s[/]",
+        title_justify="left",
+    )
     table.add_column("Function", style="dim")
     table.add_column("Calls", justify="right")
     table.add_column("Total", justify="right")
@@ -79,12 +88,20 @@ def get_stats_table():
     return table
 
 
+def get_session_duration() -> float:
+    """Get session duration in seconds."""
+    return time.perf_counter() - _start_time
+
+
 def get_stats_text() -> str:
     """Get statistics as plain text for copying."""
     if not _stats:
         return "No profiling data collected."
 
+    duration = get_session_duration()
     lines = [
+        f"Session duration: {duration:.1f}s",
+        "",
         f"{'Function':<45} {'Calls':>8} {'Total':>10} {'Avg':>10} {'Max':>10}",
         "-" * 85,
     ]

claudechic/protocols.py

@@ -22,7 +22,7 @@ class AgentManagerObserver(Protocol):
         """Called when the active agent changes."""
         ...
 
-    def on_agent_closed(self, agent_id: str) -> None:
+    def on_agent_closed(self, agent_id: str, message_count: int) -> None:
         """Called when an agent is closed."""
         ...
 

claudechic/remote.py

@@ -0,0 +1,249 @@
+"""HTTP server for remote control of claudechic.
+
+Enables external processes (like Claude in another terminal) to:
+- Take screenshots (SVG or PNG)
+- Send messages to the active agent
+- Wait for agent idle
+- Get screen content as text
+- Exit the app (for restart)
+
+Start with --remote-port flag or CLAUDECHIC_REMOTE_PORT env var.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import io
+import logging
+from pathlib import Path
+
+from rich.console import Console
+from typing import TYPE_CHECKING
+
+from aiohttp import web
+
+if TYPE_CHECKING:
+    from claudechic.app import ChatApp
+
+log = logging.getLogger(__name__)
+
+_app: ChatApp | None = None
+_server: web.AppRunner | None = None
+
+
+async def handle_screenshot(request: web.Request) -> web.Response:
+    """Save screenshot. Query params: ?path=/tmp/shot.svg&format=svg|png
+
+    For PNG, uses macOS qlmanage for conversion (falls back to SVG if unavailable).
+    """
+    if _app is None:
+        return web.json_response({"error": "App not initialized"}, status=500)
+
+    fmt = request.query.get("format", "svg")
+    default_path = f"/tmp/claudechic-screenshot.{fmt}"
+    path = request.query.get("path", default_path)
+
+    try:
+        # Always save SVG first
+        svg_path = path if fmt == "svg" else path.replace(".png", ".svg")
+        result_path = _app.save_screenshot(
+            filename=Path(svg_path).name, path=str(Path(svg_path).parent)
+        )
+
+        if fmt == "png":
+            # Convert SVG to PNG using macOS qlmanage
+            import subprocess
+
+            png_path = path if path.endswith(".png") else f"{path}.png"
+            proc = await asyncio.create_subprocess_exec(
+                "qlmanage",
+                "-t",
+                "-s",
+                "1200",
+                "-o",
+                str(Path(png_path).parent),
+                result_path,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            await proc.wait()
+            # qlmanage adds .png to the filename
+            actual_png = f"{result_path}.png"
+            if Path(actual_png).exists():
+                # Rename to requested path
+                Path(actual_png).rename(png_path)
+                result_path = png_path
+
+        return web.json_response({"path": result_path, "format": fmt})
+    except Exception as e:
+        return web.json_response({"error": str(e)}, status=500)
+
+
+async def handle_send(request: web.Request) -> web.Response:
+    """Send a message or command to the active agent. Body: {"text": "message"}
+
+    If text starts with / or !, it's treated as a command.
+    Otherwise it's sent to the agent as a prompt.
+    """
+    if _app is None:
+        return web.json_response({"error": "App not initialized"}, status=500)
+
+    try:
+        data = await request.json()
+        text = data.get("text", "")
+    except Exception:
+        # Plain text body
+        text = await request.text()
+
+    if not text:
+        return web.json_response({"error": "No text provided"}, status=400)
+
+    # Check for slash/bang commands
+    stripped = text.strip()
+    if stripped.startswith("/") or stripped.startswith("!"):
+        from claudechic.commands import handle_command as do_command
+
+        try:
+            handled = do_command(_app, text)
+            return web.json_response(
+                {"status": "executed" if handled else "not_handled", "command": text}
+            )
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=500)
+
+    # Send to active agent
+    agent = _app._agent
+    if agent is None:
+        return web.json_response({"error": "No active agent"}, status=400)
+
+    try:
+        _app._send_to_active_agent(text)
+        return web.json_response({"status": "sent", "text": text[:100]})
+    except Exception as e:
+        return web.json_response({"error": str(e)}, status=500)
+
+
+async def handle_screen_text(request: web.Request) -> web.Response:
+    """Get current screen content as plain text.
+
+    Returns the full screen rendered as text, preserving 2D layout.
+    Uses the same rendering pipeline as export_screenshot but outputs plain text.
+
+    Query params:
+        compact: If "false", include blank lines (default: true, removes blank lines)
+    """
+    compact = request.query.get("compact", "true").lower() != "false"
+    if _app is None:
+        return web.json_response({"error": "App not initialized"}, status=500)
+
+    try:
+        width, height = _app.size
+        console = Console(
+            width=width,
+            height=height,
+            file=io.StringIO(),
+            force_terminal=True,
+            color_system="truecolor",
+            record=True,
+            legacy_windows=False,
+            safe_box=False,
+        )
+        screen_render = _app.screen._compositor.render_update(
+            full=True, screen_stack=_app._background_screens
+        )
+        console.print(screen_render)
+        text = console.export_text(clear=True, styles=False)
+        if compact:
+            text = "\n".join(line for line in text.splitlines() if line.strip())
+        return web.json_response({"text": text})
+    except Exception as e:
+        return web.json_response({"error": str(e)}, status=500)
+
+
+async def handle_wait_idle(request: web.Request) -> web.Response:
+    """Wait until active agent is idle. Query param: ?timeout=30"""
+    if _app is None:
+        return web.json_response({"error": "App not initialized"}, status=500)
+
+    timeout = float(request.query.get("timeout", "30"))
+    agent = _app._agent
+    if agent is None:
+        return web.json_response({"error": "No active agent"}, status=400)
+
+    from claudechic.enums import AgentStatus
+
+    try:
+        start = asyncio.get_event_loop().time()
+        while agent.status != AgentStatus.IDLE:
+            if asyncio.get_event_loop().time() - start > timeout:
+                return web.json_response(
+                    {"error": "Timeout waiting for idle"}, status=408
+                )
+            await asyncio.sleep(0.1)
+        return web.json_response({"status": "idle"})
+    except Exception as e:
+        return web.json_response({"error": str(e)}, status=500)
+
+
+async def handle_status(request: web.Request) -> web.Response:  # noqa: ARG001
+    """Get app/agent status."""
+    if _app is None:
+        return web.json_response({"error": "App not initialized"}, status=500)
+
+    agent = _app._agent
+    agents = []
+    if _app.agent_mgr:
+        for a in _app.agent_mgr:
+            agents.append(
+                {
+                    "name": a.name,
+                    "id": a.id,
+                    "status": str(a.status),
+                    "cwd": str(a.cwd),
+                    "active": a.id == _app.agent_mgr.active_id,
+                }
+            )
+
+    return web.json_response(
+        {
+            "agents": agents,
+            "active_agent": agent.name if agent else None,
+        }
+    )
+
+
+async def handle_exit(request: web.Request) -> web.Response:  # noqa: ARG001
+    """Exit the app cleanly. Use this before restarting."""
+    if _app is None:
+        return web.json_response({"error": "App not initialized"}, status=500)
+
+    # Schedule exit after response is sent
+    async def do_exit():
+        await asyncio.sleep(0.1)  # Let response complete
+        if _app:
+            await _app._cleanup_and_exit()
+
+    asyncio.create_task(do_exit())
+    return web.json_response({"status": "exiting"})
+
+
+async def start_server(app: ChatApp, port: int) -> None:
+    """Start the remote control HTTP server."""
+    global _app, _server
+    _app = app
+
+    webapp = web.Application()
+    webapp.router.add_get("/screenshot", handle_screenshot)
+    webapp.router.add_post("/send", handle_send)
+    webapp.router.add_get("/screen_text", handle_screen_text)
+    webapp.router.add_get("/wait_idle", handle_wait_idle)
+    webapp.router.add_get("/status", handle_status)
+    webapp.router.add_post("/exit", handle_exit)
+
+    runner = web.AppRunner(webapp)
+    await runner.setup()
+    _server = runner
+
+    site = web.TCPSite(runner, "localhost", port)
+    await site.start()
+    log.info(f"Remote control server started on http://localhost:{port}")

claudechic/sessions.py

@@ -47,22 +47,48 @@ def _get_session_file(
     return session_file if session_file.exists() else None
 
 
-def _extract_preview_from_chunk(chunk: bytes) -> str | None:
-    """Extract first user message preview from a chunk of session data."""
-    for line in chunk.split(b"\n"):
+def _extract_session_info(
+    content: bytes,
+) -> tuple[str | None, str | None, int, float | None]:
+    """Extract summary, first message, count, and last timestamp from session content.
+
+    Returns (summary, first_user_message, msg_count, last_timestamp_unix).
+    """
+    from datetime import datetime
+
+    summary = None
+    first_user_msg = None
+    msg_count = 0
+    last_timestamp: float | None = None
+
+    for line in content.split(b"\n"):
         if not line.strip():
             continue
         try:
             d = json.loads(line)
-            if d.get("type") == "user" and not d.get("isMeta"):
-                content = d.get("message", {}).get("content", "")
-                if isinstance(content, str) and not content.startswith("<"):
-                    text = content.replace("\n", " ")
-                    return text[:200] + "…" if len(text) > 200 else text
+            if d.get("type") == "summary":
+                summary = d.get("summary")
+            elif d.get("type") == "user" and not d.get("isMeta"):
+                msg_count += 1
+                # Capture first user message as fallback title
+                if first_user_msg is None:
+                    text = d.get("message", {}).get("content", "")
+                    if (
+                        isinstance(text, str)
+                        and text.strip()
+                        and not text.startswith("<")
+                    ):
+                        first_user_msg = text.replace("\n", " ")[:100]
+            # Track timestamp from any entry
+            if ts := d.get("timestamp"):
+                try:
+                    dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+                    last_timestamp = dt.timestamp()
+                except ValueError:
+                    pass
         except (json.JSONDecodeError, UnicodeDecodeError):
-            # Skip lines that fail to parse (partial line at chunk boundary)
             continue
-    return None
+    return summary, first_user_msg, msg_count, last_timestamp
 
 
 async def get_recent_sessions(
@@ -70,25 +96,20 @@ async def get_recent_sessions(
 ) -> list[tuple[str, str, float, int]]:
     """Get recent sessions from a project.
 
-    Optimized for responsiveness:
-    - Reads only first 16KB of each file for preview (not entire file)
-    - Sorts by mtime first, then only reads files needed
-    - Yields to event loop periodically
-
     Args:
         limit: Maximum number of sessions to return
-        search: Optional text to filter sessions by content
+        search: Optional text to filter sessions by title
         cwd: Project directory. If None, uses current working directory.
 
     Returns:
-        List of (session_id, preview, mtime, msg_count) tuples,
+        List of (session_id, title, mtime, msg_count) tuples,
         sorted by modification time descending.
     """
     sessions_dir = get_project_sessions_dir(cwd)
     if not sessions_dir:
         return []
 
-    # Phase 1: Quick stat() to get files sorted by mtime (sync, fast)
+    # Get files sorted by mtime
     candidates = []
     for f in sessions_dir.glob("*.jsonl"):
         if not is_valid_uuid(f.stem):
@@ -96,57 +117,46 @@ async def get_recent_sessions(
         try:
             stat = f.stat()
             if stat.st_size > 0:
-                candidates.append((f, stat.st_mtime, stat.st_size))
+                candidates.append((f, stat.st_mtime))
         except OSError:
             continue
 
     candidates.sort(key=lambda x: x[1], reverse=True)
 
-    # Phase 2: Read previews from top candidates only
-    # If no search, we only need `limit` files
-    # If searching, we need to check more but can stop early
     search_lower = search.lower()
     sessions = []
-    check_limit = (
-        len(candidates) if search else limit * 2
-    )  # read a few extra in case some fail
 
-    for i, (f, mtime, size) in enumerate(candidates[:check_limit]):
-        # Yield to event loop every 10 files to stay responsive
+    for i, (f, mtime) in enumerate(candidates):
         if i > 0 and i % 10 == 0:
             await asyncio.sleep(0)
 
         try:
-            # Read only first 16KB - enough to find first user message
-            chunk_size = min(16384, size)
             async with aiofiles.open(f, mode="rb") as fh:
-                chunk = await fh.read(chunk_size)
-
-            preview = _extract_preview_from_chunk(chunk)
-            if not preview:
-                continue
-
-            # For search, check if preview matches (simplified - only checks preview, not full content)
-            if search and search_lower not in preview.lower():
-                continue
+                content = await fh.read()
+            summary, first_msg, msg_count, last_ts = _extract_session_info(content)
+            title = summary or first_msg or f.stem[:8]
+            # Prefer timestamp from file content over file mtime
+            effective_time = last_ts or mtime
+        except (IOError, OSError):
+            title = f.stem[:8]
+            msg_count = 0
+            effective_time = mtime
 
-            # msg_count is now approximate (we don't read whole file)
-            sessions.append((f.stem, preview, mtime, 1))
+        if msg_count == 0:
+            continue
+        if search and search_lower not in title.lower():
+            continue
 
-            # Early exit if we have enough and not searching
-            if not search and len(sessions) >= limit:
-                break
+        sessions.append((f.stem, title, effective_time, msg_count))
 
-        except (IOError, OSError):
-            continue
+        if not search and len(sessions) >= limit:
+            break
 
     return sessions[:limit]
 
 
-async def load_session_messages(
-    session_id: str, limit: int = 10, cwd: Path | None = None
-) -> list[dict]:
-    """Load recent messages from a session file.
+async def load_session_messages(session_id: str, cwd: Path | None = None) -> list[dict]:
+    """Load all messages from a session file.
 
     Returns list of message dicts with 'type' key:
     - user: {'type': 'user', 'content': str}
@@ -194,7 +204,7 @@ async def load_session_messages(
     except (json.JSONDecodeError, IOError):
         pass
 
-    return messages[-limit:]
+    return messages
 
 
 async def get_plan_path_for_session(

claudechic/styles.tcss

@@ -2,9 +2,18 @@
  *
  * CSS POLICY:
  * -----------
- * Widgets use DEFAULT_CSS for co-located styles (Tailwind-style).
- * This file contains app-level layout and shared styles.
- * Use theme variables ($primary, $surface, etc.) - avoid hardcoded hex colors.
+ * DEFAULT_CSS (inline): Use for structural styles that are essential to the widget
+ *   - Dimensions (width, height, min-width)
+ *   - Layout properties (padding, margin for structure)
+ *   - Display modes (display: none for hidden states)
+ *
+ * styles.tcss (this file): Use for visual/thematic styles
+ *   - Colors (use theme variables: $primary, $surface, etc.)
+ *   - Borders for visual grouping
+ *   - Hover effects and interactive states
+ *   - App-level layout coordination
+ *
+ * Avoid hardcoded hex colors - use theme variables.
  *
  * Visual language: All content blocks use left border bars to indicate type.
  * - User messages: vibrant orange border ($primary)
@@ -158,7 +167,7 @@ ToolUseWidget {
     margin: 0;
 }
 
-ToolUseWidget:hover, ToolUseWidget.hovered {
+ToolUseWidget:hover {
     border-left: wide $panel-lighten-2;
     background: $surface;
 }
@@ -186,7 +195,7 @@ ShellOutputWidget {
     margin: 1 0;
 }
 
-ShellOutputWidget:hover, ShellOutputWidget.hovered {
+ShellOutputWidget:hover {
     border-left: wide $warning-lighten-1;
     background: $surface;
 }
@@ -208,7 +217,7 @@ ShellOutputWidget #shell-output {
 }
 
 
-/* Copy buttons - overlaid, hidden until hover */
+/* Copy buttons - hidden until hovered */
 .copy-btn {
     layer: above;
     dock: right;
@@ -219,19 +228,10 @@ ShellOutputWidget #shell-output {
     text-align: center;
     background: transparent;
     border: none;
-    color: transparent;  /* Hidden by default via transparent color */
+    color: transparent;
 }
 
-ChatMessage:hover .copy-btn,
-ChatMessage.hovered .copy-btn,
-ToolUseWidget:hover .copy-btn,
-ToolUseWidget.hovered .copy-btn,
-ShellOutputWidget:hover .copy-btn,
-ShellOutputWidget.hovered .copy-btn {
-    color: $text-muted;  /* Visible on hover */
-}
-
-Button.copy-btn:hover {
+.copy-btn:hover {
     color: $primary !important;
     background: transparent !important;
 }
@@ -256,6 +256,7 @@ Button.copy-btn:hover {
 
 /* Chat views - both initial and dynamically created */
 #chat-view, .chat-view {
+    layout: stream;
     width: 1fr;
     max-width: 100;
     padding: 1 1;
@@ -422,7 +423,7 @@ MarkdownH2 {
 MarkdownH3 {
     color: $text;
     text-style: bold;
-    margin: 1 0 0 0;
+    margin: 1 0 1 0;
 }
 
 MarkdownTableContent > .header {