codicent-cli 0.8.4__tar.gz → 0.8.6__tar.gz

{codicent_cli-0.8.4 → codicent_cli-0.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codicent-cli
-Version: 0.8.4
+Version: 0.8.6
 Summary: Command-line interface for the Codicent API
 Home-page: https://github.com/izaxon/codicent-cli
 Author: Johan Isaksson

{codicent_cli-0.8.4 → codicent_cli-0.8.6}/app.py

@@ -123,6 +123,23 @@ TERMINAL (Web Terminal Host):
         codicent terminal bash
         codicent terminal zsh
 
+TUI (Text User Interface):
+    tui                 Open a split-screen terminal UI with a logbook home panel on
+                        the left (recent messages + compose) and an AI chat panel on
+                        the right. Uses the same authentication as other commands.
+
+    Key bindings:
+        Tab / Shift+Tab     Switch focus between compose and chat inputs
+        Enter               Send the current input
+        Escape + Enter      Insert a newline in the active input
+        Ctrl+R              Refresh message list
+        F1  or  Alt+1       Focus compose input
+        F2  or  Alt+2       Focus chat input
+        Ctrl+C              Quit
+
+    Example:
+        codicent tui
+
 EXAMPLES:
     codicent auth
     codicent "What is Python?"
@@ -133,6 +150,7 @@ EXAMPLES:
     codicent wrap claude
     codicent terminal
     codicent daemon
+    codicent tui
     codicent update
     codicent update --install
     echo "Help me debug this" | codicent
@@ -1015,6 +1033,31 @@ def main():
             project=wrap_project,
         )
 
+    # Handle tui command
+    if len(sys.argv) > 1 and sys.argv[1] == "tui":
+        from tui import run_tui
+
+        tui_token = auth.get_cached_token()
+        if not tui_token:
+            tui_token = os.getenv("CODICENT_TOKEN")
+        if not tui_token:
+            console.print("[red]❌ No authentication found.[/red]")
+            console.print("[dim]Run 'codicent auth' to authenticate, or set CODICENT_TOKEN[/dim]")
+            return 1
+
+        try:
+            tui_payload = tui_token.split(".")[1]
+            tui_payload += '=' * (-len(tui_payload) % 4)
+            tui_jwt = json.loads(base64.urlsafe_b64decode(tui_payload).decode('utf-8'))
+            tui_project = tui_jwt["project"]
+        except Exception as e:
+            console.print(f"[red]❌ Failed to extract project from token: {e}[/red]")
+            return 1
+
+        tui_codicent = Codicent(tui_token)
+        run_tui(tui_codicent, tui_project)
+        return 0
+
     # Handle terminal command
     if len(sys.argv) > 1 and sys.argv[1] == "terminal":
         from terminal import run_terminal_host

{codicent_cli-0.8.4 → codicent_cli-0.8.6}/codicent_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codicent-cli
-Version: 0.8.4
+Version: 0.8.6
 Summary: Command-line interface for the Codicent API
 Home-page: https://github.com/izaxon/codicent-cli
 Author: Johan Isaksson

{codicent_cli-0.8.4 → codicent_cli-0.8.6}/codicent_cli.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ app.py
 auth.py
 setup.py
 terminal.py
+tui.py
 wrap.py
 codicent_cli.egg-info/PKG-INFO
 codicent_cli.egg-info/SOURCES.txt

{codicent_cli-0.8.4 → codicent_cli-0.8.6}/codicent_cli.egg-info/top_level.txt

@@ -2,4 +2,5 @@ app
 auth
 templates
 terminal
+tui
 wrap

{codicent_cli-0.8.4 → codicent_cli-0.8.6}/setup.py

@@ -9,7 +9,7 @@ except FileNotFoundError:
 
 setup(
     name='codicent-cli',
-    version='0.8.4',
+    version='0.8.6',
     author='Johan Isaksson',
     author_email='johan@izaxon.com',
     description='Command-line interface for the Codicent API',
@@ -35,7 +35,7 @@ setup(
         'Programming Language :: Python :: 3.12',
     ],
     keywords='codicent cli api chat ai',
-    py_modules=['app', 'auth', 'wrap', 'terminal'],
+    py_modules=['app', 'auth', 'wrap', 'terminal', 'tui'],
     packages=['templates'],
     package_data={'templates': ['*.json']},
     python_requires='>=3.6',

codicent_cli-0.8.6/tui.py

@@ -0,0 +1,1169 @@
+"""
+Codicent TUI — responsive terminal user interface.
+
+Wide terminals (≥80 cols) — split-screen:
+  Left panel:  Logbook — messages list (↑/↓ navigate when input is empty)
+  Right panel: Context-aware — three modes:
+               "ai-chat"  — New chat (nothing selected)
+               "thread"   — Full conversation thread (#chat/#chat2 selected)
+               "detail"   — Full message content (any other selection)
+
+Narrow terminals (<80 cols) — single-pane swap:
+  Tab swaps between Logbook and the right pane. The chat input stays visible
+  at the bottom regardless of which pane is showing.
+
+Input — single field, label reflects what Enter will do:
+  "New chat ›"   no selection           → new AI chat
+  "Reply ›"     #chat/#chat2 selected   → reply in thread
+  "Update ›"    other message selected  → post child update (parent_id set)
+
+Slash commands (typed in the input, mobile-friendly alternates to Ctrl-combos):
+  /post [text]    plain post (parent-linked if a message is selected)
+  /spawn [text]   fire-and-forget chat
+  /new [text]     clear selection; if text given, send as new chat
+  /refresh        reload logbook
+  /help (or /?)   help overlay
+  /quit           exit
+  //foo           literal: send the text "/foo"
+
+Key bindings:
+  Enter     send (per current mode)
+  Tab       (narrow only) swap between Logbook and right pane
+  ?         (input empty) toggle help overlay
+  Esc       close help / clear input / deselect
+  Ctrl+P    post (same as /post)
+  Ctrl+J    spawn (same as /spawn)
+  Ctrl+N    new chat (same as /new)
+  Ctrl+R    refresh
+  Ctrl+C    quit
+  ↑/↓       navigate logbook (input empty) or scroll right panel (input has text)
+"""
+
+import re
+import sys
+import threading
+from datetime import datetime
+
+import requests as _requests
+
+from prompt_toolkit import Application
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.input.defaults import create_input
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout.containers import (
+    DynamicContainer,
+    HSplit,
+    VSplit,
+    Window,
+    WindowAlign,
+)
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.layout import Layout
+from prompt_toolkit.output.color_depth import ColorDepth
+from prompt_toolkit.output.defaults import create_output
+from prompt_toolkit.output.vt100 import Vt100_Output
+if sys.platform == "win32":
+    from prompt_toolkit.output.win32 import NoConsoleScreenBufferError
+else:
+    class NoConsoleScreenBufferError(Exception):  # noqa: N818 - mirror upstream name
+        """Stub for non-Windows platforms; never actually raised."""
+from prompt_toolkit.styles import Style
+from prompt_toolkit.utils import get_bell_environment_variable, get_term_environment_variable
+from prompt_toolkit.widgets import Frame, TextArea
+
+
+def _pick_tty_stream(*streams):
+    for stream in streams:
+        try:
+            if stream is not None and stream.isatty():
+                return stream
+        except Exception:
+            pass
+    return None
+
+
+def _create_prompt_io():
+    input_stream = _pick_tty_stream(sys.stdin, sys.stdout, sys.stderr)
+    output_stream = _pick_tty_stream(sys.stdout, sys.stderr, sys.__stdout__)
+
+    pt_input = create_input(stdin=input_stream, always_prefer_tty=True)
+    try:
+        pt_output = create_output(stdout=output_stream, always_prefer_tty=True)
+    except NoConsoleScreenBufferError:
+        if output_stream is None:
+            raise
+        pt_output = Vt100_Output.from_pty(
+            output_stream,
+            term=get_term_environment_variable(),
+            default_color_depth=ColorDepth.from_env(),
+            enable_bell=get_bell_environment_variable(),
+        )
+
+    return pt_input, pt_output
+
+# ---------------------------------------------------------------------------
+# Styles
+# ---------------------------------------------------------------------------
+
+STYLE = Style.from_dict(
+    {
+        # Chrome
+        "title":            "bold #00d7ff",
+        "status-bar":       "bg:#1a1a2e #888888",
+        "status-key":       "bg:#1a1a2e bold #ffffff",
+        "status-mode":      "bg:#1a1a2e bold #00d7ff",
+        "frame-label":      "bold #00d7ff",
+        "focused-frame":    "bold #00d7ff",
+        # Logbook list
+        "msg-tags":         "#00d7af",
+        "msg-time":         "#555555",
+        "msg-content":      "#cccccc",
+        "msg-selected":     "bg:#263366 bold",
+        "msg-selected-tag": "bg:#263366 #00d7af bold",
+        "msg-file":         "#ffaf5f",
+        # Right panel — ai-chat mode
+        "chat-you":         "#87d7ff bold",
+        "chat-ai":          "#98fb98",
+        "chat-thinking":    "italic #888888",
+        # Right panel — thread / detail mode
+        "detail-label":     "bold #aaaaaa",
+        "detail-body":      "#dddddd",
+        "detail-url":       "underline #87d7ff",
+        "md-h1":            "bold #ffffff",
+        "md-h2":            "bold #e0e0e0",
+        "md-h3":            "bold #cccccc",
+        "md-bold":          "bold",
+        "md-bullet":        "#888888",
+        "md-code":          "bg:#1e1e1e #ffaf5f",
+        # Inputs
+        "compose-input":    "",
+        "chat-input":       "",
+    }
+)
+
+_MAX_VISIBLE            = 12  # ceiling for messages rendered in the logbook slice
+_LINES_PER_MSG          =  3  # newlines per message in FormattedTextControl output
+NARROW_WIDTH_THRESHOLD  = 80  # below this column count, switch to single-pane layout
+
+# ---------------------------------------------------------------------------
+# Pure helpers
+# ---------------------------------------------------------------------------
+
+_FILE_RE  = re.compile(r"#file:([0-9a-fA-F-]{36})")
+_TAG_RE   = re.compile(r"#(\w[\w-]*)")
+_BOLD_RE  = re.compile(r"\*\*(.+?)\*\*|__(.+?)__")
+_CODE_RE  = re.compile(r"`([^`]+)`")
+
+
+def _md_line_fragments(line: str, base_style: str) -> list[tuple[str, str]]:
+    """Convert one line of markdown to a list of (style, text) fragments."""
+    stripped = line.rstrip()
+
+    # Headings
+    if stripped.startswith("### "):
+        return [("class:md-h3", "  " + stripped[4:] + "\n")]
+    if stripped.startswith("## "):
+        return [("class:md-h2", "  " + stripped[3:] + "\n")]
+    if stripped.startswith("# "):
+        return [("class:md-h1", "  " + stripped[2:] + "\n")]
+
+    # Bullet points
+    bullet_match = re.match(r"^(\s*)([-*+]|\d+\.) (.+)", stripped)
+    if bullet_match:
+        indent = bullet_match.group(1)
+        rest   = bullet_match.group(3)
+        frags  = [("class:md-bullet", "  " + indent + "• ")]
+        frags += _md_inline_fragments(rest, base_style)
+        frags.append(("class:detail-body", "\n"))
+        return frags
+
+    # Blank line
+    if not stripped:
+        return [("class:detail-body", "\n")]
+
+    # Normal line with inline formatting
+    frags = [("class:detail-body", "  ")]
+    frags += _md_inline_fragments(stripped, base_style)
+    frags.append(("class:detail-body", "\n"))
+    return frags
+
+
+def _md_inline_fragments(text: str, base_style: str) -> list[tuple[str, str]]:
+    """Parse bold (**…**/__…__) and inline code (`…`) within a text span."""
+    frags: list[tuple[str, str]] = []
+    combined = re.compile(r"\*\*(.+?)\*\*|__(.+?)__|`([^`]+)`")
+    pos = 0
+    for m in combined.finditer(text):
+        if m.start() > pos:
+            frags.append((base_style, text[pos:m.start()]))
+        if m.group(1) is not None or m.group(2) is not None:
+            frags.append(("class:md-bold", m.group(1) or m.group(2)))
+        else:
+            frags.append(("class:md-code", m.group(3)))
+        pos = m.end()
+    if pos < len(text):
+        frags.append((base_style, text[pos:]))
+    return frags or [(base_style, text)]
+
+
+def _fmt_time(created_at: str) -> str:
+    """Return a short HH:MM time string from an ISO timestamp."""
+    try:
+        dt = datetime.fromisoformat(created_at.replace("Z", "+00:00"))
+        return dt.strftime("%H:%M")
+    except Exception:
+        return ""
+
+
+def _extract_tags(content: str) -> list[str]:
+    return _TAG_RE.findall(content)
+
+
+def _strip_prefix(content: str) -> str:
+    """Strip leading @mention and #tag tokens from the first line; keep the rest."""
+    import re
+    lines = content.splitlines()
+    if not lines:
+        return content
+    # Remove any run of @word or #word tokens at the start of the first line
+    first_body = re.sub(r"^([@#]\S+\s*)+", "", lines[0]).strip()
+    rest = lines[1:]
+    parts = ([first_body] if first_body else []) + rest
+    return "\n".join(parts).strip()
+
+
+def _is_chat_message(content: str) -> bool:
+    tags = _extract_tags(content)
+    return "chat" in tags or "chat2" in tags
+
+
+_CHAT_MSG_TYPES = {"ai-chat-answer", "ai-chat-answer2", "ai-chat-prompt", "ai-chat-prompt2"}
+
+
+def _deduplicate_chat(msgs: list[dict]) -> list[dict]:
+    """Collapse chat-type messages with the same originalMessageId to one entry.
+
+    Messages arrive oldest-first after the caller reverses the API list.
+    Each successive message with the same root is newer, so we replace the
+    previous entry in-place — position stays stable, content is freshest.
+    """
+    result: list[dict] = []
+    # maps originalMessageId (str) -> index in result
+    seen: dict[str, int] = {}
+
+    for msg in msgs:
+        msg_type = (msg.get("type") or msg.get("Type", "")).lower()
+        content  = msg.get("content") or msg.get("Content", "")
+        is_chat  = msg_type in _CHAT_MSG_TYPES or _is_chat_message(content)
+
+        if not is_chat:
+            result.append(msg)
+            continue
+
+        raw_orig = msg.get("originalMessageId") or msg.get("OriginalMessageId")
+        if not raw_orig:
+            result.append(msg)
+            continue
+
+        orig_id = str(raw_orig)
+        if orig_id in seen:
+            result[seen[orig_id]] = msg   # replace with newer entry
+        else:
+            seen[orig_id] = len(result)
+            result.append(msg)
+
+    return result
+
+
+def _has_file_ref(content: str) -> bool:
+    return bool(_FILE_RE.search(content))
+
+
+def _resolve_file_refs(content: str, base_url: str) -> str:
+    """Replace #file:GUID with a download URL."""
+    def _replace(m):
+        guid = m.group(1)
+        url = f"{base_url.rstrip('/')}/app/DownloadFile?id={guid}"
+        return f"↓ {url}"
+    return _FILE_RE.sub(_replace, content)
+
+
+# ---------------------------------------------------------------------------
+# TUI class
+# ---------------------------------------------------------------------------
+
+
+class CodicentTUI:
+
+    def __init__(self, codicent, project: str):
+        self.codicent = codicent
+        self.project  = project
+
+        # --- Logbook state ---
+        self._messages: list[dict]       = []
+        self._selected_index: int | None = None
+        self._view_top: int              = 0     # first rendered msg in viewport slice
+        self._messages_scroll_pos: int   = 9999  # Window vertical_scroll target
+
+        # --- Right-panel state ---
+        # mode: "ai-chat" | "thread" | "detail"
+        self._right_mode: str             = "ai-chat"
+        self._thread_messages: list[dict] = []
+        self._right_scroll_pos: int       = 0     # scroll position when in manual mode
+        self._right_manual_scroll: bool   = False  # True = use _right_scroll_pos; False = auto-bottom
+        self._right_total_lines: int      = 0     # line count of last rendered right panel
+
+        # --- AI-chat state ---
+        self._chat_lines: list[tuple[str, str]] = []   # (role, text)
+        self._conversation_id = None
+        self._ai_thinking      = False
+
+        # --- Status ---
+        self._status_text = "Ready"
+
+        # --- Responsive layout state ---
+        # Which pane is visible in narrow mode. Default "right" so the input is
+        # immediately usable; selecting a logbook row drills into "right".
+        self._narrow_active: str = "right"
+        self._show_help: bool    = False
+
+        self._build_ui()
+
+    # ------------------------------------------------------------------
+    # Data helpers
+    # ------------------------------------------------------------------
+
+    def _load_messages(self):
+        """Fetch recent messages. Runs in background thread."""
+        try:
+            self._status_text = "Refreshing…"
+            self._refresh_display()
+            msgs = self.codicent.get_messages(start=0, length=20)
+            # Reverse so oldest first, newest last (bottom of list)
+            raw = list(reversed(msgs if isinstance(msgs, list) else []))
+            self._messages = _deduplicate_chat(raw)
+        except Exception as e:
+            self._status_text = f"Refresh error: {e}"
+        else:
+            self._status_text = f"Loaded {len(self._messages)} message(s)"
+        self._adjust_viewport()
+        self._refresh_display()
+
+    def _post_message(self, text: str, parent_id=None):
+        """Post a message (or update an existing one). Runs in background thread."""
+        text = text.strip()
+        if not text:
+            return
+        # For edits, remember the originalMessageId so we can re-select after reload.
+        orig_id = None
+        if parent_id and self._selected_index is not None:
+            msg = self._messages[self._selected_index]
+            raw = msg.get("originalMessageId") or msg.get("OriginalMessageId") or \
+                  msg.get("id") or msg.get("Id")
+            orig_id = str(raw) if raw else None
+        try:
+            self._status_text = "Posting…"
+            self._refresh_display()
+            self.codicent.post_message(text, parent_id=parent_id, type="info")
+            self._status_text = "Updated!" if parent_id else "Posted!"
+        except Exception as e:
+            self._status_text = f"Post error: {e}"
+        if parent_id:
+            # Old message is versioned out; clear stale index before reload
+            self._selected_index = None
+            self._right_mode = "ai-chat"
+            self._conversation_id = None
+        self._load_messages()
+        if orig_id:
+            self._auto_select_by_orig_id(orig_id)
+
+    def _auto_select_by_orig_id(self, orig_id: str):
+        """Select the logbook row whose originalMessageId matches orig_id."""
+        for i, msg in enumerate(self._messages):
+            omid = str(msg.get("originalMessageId") or msg.get("OriginalMessageId") or
+                       msg.get("id") or msg.get("Id", ""))
+            if omid == orig_id:
+                self._selected_index = i
+                self._adjust_viewport()
+                self._on_selection_changed()
+                return
+
+    def _send_chat(self, text: str):
+        """Send chat + get AI reply, then reload logbook. Runs in background thread."""
+        text = text.strip()
+        if not text:
+            return
+        was_new_chat = (self._right_mode == "ai-chat")
+        self._chat_lines.append(("you", text))
+        # Immediately show the user's message in the right panel
+        if self._right_mode == "thread":
+            self._thread_messages.append({
+                "type": "ai-chat-prompt",
+                "content": text,
+                "createdAt": datetime.utcnow().isoformat() + "Z",
+            })
+            self._right_manual_scroll = False  # snap to bottom
+        elif was_new_chat:
+            # Switch immediately to thread mode so new chat shows as a conversation
+            self._thread_messages = [{
+                "type": "ai-chat-prompt",
+                "content": text,
+                "createdAt": datetime.utcnow().isoformat() + "Z",
+            }]
+            self._right_mode = "thread"
+            self._right_manual_scroll = False
+        self._ai_thinking = True
+        self._status_text  = "Thinking…"
+        self._refresh_display()
+        try:
+            resp = self.codicent.post_chat_reply(text, self._conversation_id)
+            self._conversation_id = resp["id"]
+            ai_text = resp.get("content", "")
+            self._chat_lines.append(("ai", ai_text))
+            # Add AI reply to thread view immediately
+            self._thread_messages.append({
+                "type": "ai-chat-answer",
+                "content": ai_text,
+                "createdAt": datetime.utcnow().isoformat() + "Z",
+            })
+            self._right_manual_scroll = False
+            self._status_text = "Done"
+        except Exception as e:
+            self._chat_lines.append(("ai", f"[Error: {e}]"))
+            self._status_text = f"Chat error: {e}"
+        finally:
+            self._ai_thinking = False
+        self._refresh_display()
+        # Reload logbook so new chat message appears, then auto-select it
+        self._load_messages()
+        self._auto_select_conversation()
+
+    def _spawn_chat(self, text: str):
+        """Fire-and-forget: start a new background chat without changing the view."""
+        text = text.strip()
+        if not text:
+            return
+        self._status_text = "Spawning…"
+        self._refresh_display()
+        try:
+            resp = self.codicent.post_chat_reply(text, None)
+            self._status_text = "Spawned!"
+        except Exception as e:
+            self._status_text = f"Spawn error: {e}"
+        # Reload logbook so the new thread appears; do NOT auto-select it
+        self._load_messages()
+
+    def _fetch_thread(self, msg_id: str):
+        """Fetch full conversation thread. Runs in background thread."""
+        try:
+            self._status_text = f"Loading thread {msg_id[:8]}…"
+            self._refresh_display()
+            url = f"{self.codicent.base_url.rstrip('/')}/api/GetMessageHistory"
+            resp = _requests.get(
+                url,
+                params={"messageId": msg_id},
+                headers={"Authorization": f"Bearer {self.codicent.token}"},
+                verify=self.codicent.verify_https,
+                timeout=15,
+            )
+            if not resp.ok:
+                snippet = resp.text[:120].replace("\n", " ")
+                self._thread_messages = []
+                self._status_text = f"Thread HTTP {resp.status_code}: {snippet}"
+                self._refresh_display()
+                return
+            text = resp.text.strip()
+            if not text:
+                self._thread_messages = []
+                self._status_text = "Thread: empty response"
+                self._refresh_display()
+                return
+            data = resp.json()
+            self._thread_messages = data if isinstance(data, list) else []
+            self._status_text = f"Thread: {len(self._thread_messages)} message(s)"
+        except Exception as e:
+            self._thread_messages = []
+            self._status_text = f"Thread error: {e}"
+        self._refresh_display()
+
+    # ------------------------------------------------------------------
+    # Terminal size helpers
+    # ------------------------------------------------------------------
+
+    def _term_size(self):
+        """Return (cols, rows) reading the current Application output. Safe to
+        call before .run() — falls back to (80, 24) if the app isn't ready."""
+        try:
+            size = get_app().output.get_size()
+            return size.columns, size.rows
+        except Exception:
+            return 80, 24
+
+    def _is_narrow(self) -> bool:
+        cols, _ = self._term_size()
+        return cols < NARROW_WIDTH_THRESHOLD
+
+    def _max_visible(self) -> int:
+        """Cap the logbook slice at _MAX_VISIBLE but shrink for short terminals.
+        Reserves rows for title, frame borders, input (up to 5), and status."""
+        _, rows = self._term_size()
+        return min(_MAX_VISIBLE, max(3, rows - 8))
+
+    # ------------------------------------------------------------------
+    # Viewport helper
+    # ------------------------------------------------------------------
+
+    def _adjust_viewport(self):
+        """Scroll _view_top so the selected row (or newest) is visible."""
+        n = len(self._messages)
+        if n == 0:
+            self._view_top = 0
+            return
+        max_visible = self._max_visible()
+        if self._selected_index is None:
+            # No selection → show the newest messages (bottom of list)
+            self._view_top = max(0, n - max_visible)
+        else:
+            # Clamp selection first
+            idx = max(0, min(n - 1, self._selected_index))
+            # Scroll up if selected row is above viewport
+            if idx < self._view_top:
+                self._view_top = idx
+            # Scroll down if selected row is below viewport
+            elif idx >= self._view_top + max_visible:
+                self._view_top = idx - max_visible + 1
+        # Safety clamp
+        self._view_top = max(0, min(self._view_top, max(0, n - max_visible)))
+
+        # Update Window scroll to make the right content visible.
+        # Use the actual rendered line count (not 9999) so prompt_toolkit clamps correctly.
+        n_shown = min(n, max_visible)
+        header = 1 if self._view_top > 0 else 0
+        total_rendered = header + n_shown * _LINES_PER_MSG
+        if self._selected_index is None:
+            # No selection → show newest (bottom of rendered content)
+            self._messages_scroll_pos = total_rendered
+        else:
+            pos_in_slice = self._selected_index - self._view_top
+            # Scroll selected item to top of visible area
+            self._messages_scroll_pos = max(0, header + pos_in_slice * _LINES_PER_MSG)
+
+    # ------------------------------------------------------------------
+    # Selection / mode helpers
+    # ------------------------------------------------------------------
+
+    def _on_selection_changed(self):
+        """Called whenever _selected_index changes. Updates right-panel mode."""
+        if self._selected_index is None:
+            self._right_mode = "ai-chat"
+            self._right_scroll_pos = 9999
+            self._refresh_display()
+            return
+
+        # Drill-in: in narrow mode, selecting from the logbook surfaces the
+        # right pane so the user can read/reply without an extra Tab.
+        if self._is_narrow():
+            self._narrow_active = "right"
+
+        msg      = self._messages[self._selected_index]
+        content  = msg.get("content") or msg.get("Content", "")
+        msg_id   = str(msg.get("id") or msg.get("Id", ""))
+        msg_type = (msg.get("type") or msg.get("Type", "")).lower()
+        # Use originalMessageId as the thread root (AI replies carry it).
+        # Only fall back to msg_id if originalMessageId is absent or falsy (0/null).
+        raw_orig = msg.get("originalMessageId") or msg.get("OriginalMessageId")
+        orig_id  = str(raw_orig) if raw_orig else msg_id
+
+        is_chat = _is_chat_message(content) or msg_type in _CHAT_MSG_TYPES
+        if is_chat:
+            self._right_mode          = "thread"
+            self._right_manual_scroll = False  # auto-scroll to bottom
+            self._conversation_id     = orig_id  # Ask › replies into this thread
+            threading.Thread(
+                target=self._fetch_thread, args=(orig_id,), daemon=True
+            ).start()
+        else:
+            self._right_mode          = "detail"
+            self._right_manual_scroll = True   # manual so we start at pos 0 (top)
+            self._right_scroll_pos    = 0
+            self._thread_messages     = []
+            self._refresh_display()
+
+    def _move_selection(self, delta: int):
+        if not self._messages:
+            return
+        if self._selected_index is None:
+            # ↓ starts at newest (bottom), ↑ starts at newest too
+            self._selected_index = len(self._messages) - 1 if delta > 0 else len(self._messages) - 1
+        else:
+            self._selected_index = max(
+                0, min(len(self._messages) - 1, self._selected_index + delta)
+            )
+        self._adjust_viewport()
+        self._on_selection_changed()
+
+    def _clear_selection(self):
+        self._selected_index    = None
+        self._right_mode        = "ai-chat"
+        self._conversation_id   = None
+        self._right_manual_scroll = False  # back to auto-bottom
+        self._show_help          = False
+        # Pop back to the logbook in narrow mode so deselect feels like "back".
+        if self._is_narrow():
+            self._narrow_active = "logbook"
+        self._adjust_viewport()
+        self._refresh_display()
+
+    def _auto_select_conversation(self):
+        """After a chat reply, find the conversation in the logbook and select it."""
+        if not self._conversation_id or not self._messages:
+            return
+        cid = str(self._conversation_id)
+        for i, msg in enumerate(self._messages):
+            mid  = str(msg.get("id")           or msg.get("Id", ""))
+            omid = str(msg.get("originalMessageId") or msg.get("OriginalMessageId", ""))
+            if cid in (mid, omid):
+                if i != self._selected_index:
+                    self._selected_index = i
+                    self._adjust_viewport()
+                    self._on_selection_changed()
+                return
+        # Conversation not found by id — fall back to selecting newest chat message
+        for i in range(len(self._messages) - 1, -1, -1):
+            content = self._messages[i].get("content") or self._messages[i].get("Content", "")
+            if _is_chat_message(content):
+                self._selected_index = i
+                self._adjust_viewport()
+                self._on_selection_changed()
+                return
+
+    # ------------------------------------------------------------------
+    # Formatted-text builders
+    # ------------------------------------------------------------------
+
+    def _build_messages_text(self):
+        result = []
+        n = len(self._messages)
+        if n == 0:
+            result.append(("class:msg-content", "  No messages yet.\n"))
+            return result
+
+        start = self._view_top
+        end   = min(n, start + self._max_visible())
+
+        # "── N older ──" header
+        if start > 0:
+            result.append(("class:msg-time", f"  ── {start} older ──\n"))
+
+        for i in range(start, end):
+            msg      = self._messages[i]
+            content  = msg.get("content") or msg.get("Content", "")
+            created  = msg.get("createdAt") or msg.get("CreatedAt", "")
+            selected = (i == self._selected_index)
+
+            tags     = _extract_tags(content)
+            body     = _strip_prefix(content)
+            time_str = _fmt_time(created)
+            has_file = _has_file_ref(content)
+
+            tag_style  = "class:msg-selected-tag" if selected else "class:msg-tags"
+            time_style = "class:msg-selected"     if selected else "class:msg-time"
+            body_style = "class:msg-selected"     if selected else "class:msg-content"
+
+            tag_str = " ".join(f"#{t}" for t in tags[:5])
+            if has_file:
+                tag_str += " 📎"
+            if selected:
+                tag_str = "▶ " + tag_str
+
+            result.append((tag_style, f"  {tag_str}"))
+            if time_str:
+                result.append((time_style, f"  {time_str}"))
+            result.append(("", "\n"))
+
+            if body:
+                display = body[:80] + ("…" if len(body) > 80 else "")
+                result.append((body_style, f"  {display}\n"))
+
+            result.append(("class:msg-time", "  " + "─" * 40 + "\n"))
+
+        # "── N newer ──" footer
+        remaining = n - end
+        if remaining > 0:
+            result.append(("class:msg-time", f"  ── {remaining} newer ──\n"))
+
+        return result
+
+    def _input_prompt_text(self) -> str:
+        """Dynamic label for the single unified input field."""
+        labels = {
+            "ai-chat": "New chat ›  ",
+            "thread":  "Reply     ›  ",
+            "detail":  "Update    ›  ",
+        }
+        return labels.get(self._right_mode, "          ›  ")
+
+    def _build_right_panel_text(self):
+        """Build formatted text for the right panel according to current mode."""
+        if self._show_help:
+            frags = self._build_help_text()
+        else:
+            mode = self._right_mode
+            if mode == "thread":
+                frags = self._build_thread_text()
+            elif mode == "detail":
+                frags = self._build_detail_text()
+            else:
+                frags = self._build_ai_chat_text()
+        self._right_total_lines = sum(text.count("\n") for _, text in frags)
+        return frags
+
+    def _build_help_text(self):
+        """Static help overlay shown when _show_help is True."""
+        rows = [
+            ("class:md-h2",       "  Codicent TUI — help\n"),
+            ("class:detail-body", "\n"),
+            ("class:detail-label","  Enter (per current mode)\n"),
+            ("class:detail-body", "    no selection      → start a new AI chat\n"),
+            ("class:detail-body", "    chat selected     → reply in thread\n"),
+            ("class:detail-body", "    other selected    → post child update\n"),
+            ("class:detail-body", "\n"),
+            ("class:detail-label","  Slash commands (type into the input)\n"),
+            ("class:detail-body", "    /post [text]    plain post (parent-linked if selected)\n"),
+            ("class:detail-body", "    /spawn [text]   fire-and-forget chat\n"),
+            ("class:detail-body", "    /new [text]     clear selection (and send if text)\n"),
+            ("class:detail-body", "    /refresh        reload logbook\n"),
+            ("class:detail-body", "    /help, /?       toggle this help\n"),
+            ("class:detail-body", "    /quit           exit\n"),
+            ("class:detail-body", "    //foo           literal: send the text \"/foo\"\n"),
+            ("class:detail-body", "\n"),
+            ("class:detail-label","  Keys\n"),
+            ("class:detail-body", "    Tab        (narrow) swap Logbook ↔ right pane\n"),
+            ("class:detail-body", "    ?          (input empty) toggle help\n"),
+            ("class:detail-body", "    Esc        close help / clear input / deselect\n"),
+            ("class:detail-body", "    Ctrl+P     post           Ctrl+J  spawn\n"),
+            ("class:detail-body", "    Ctrl+N     new chat       Ctrl+R  refresh\n"),
+            ("class:detail-body", "    Ctrl+C     quit\n"),
+            ("class:detail-body", "    ↑/↓        navigate logbook (input empty) or scroll right\n"),
+            ("class:detail-body", "\n"),
+            ("class:msg-time",    "  Press ? or Esc to close.\n"),
+        ]
+        return rows
+
+    def _build_ai_chat_text(self):
+        result = []
+        if not self._chat_lines:
+            result.append(("class:msg-content", "  No chat history yet.\n"))
+            return result
+        for role, text in self._chat_lines[-30:]:
+            if role == "you":
+                result.append(("class:chat-you", "  You: "))
+                result.append(("class:msg-content", text + "\n"))
+            else:
+                result.append(("class:chat-ai", "  AI:  "))
+                result.append(("class:msg-content", text + "\n"))
+            result.append(("class:msg-time", "\n"))
+        if self._ai_thinking:
+            result.append(("class:chat-thinking", "  AI is thinking…\n"))
+        return result
+
+    def _build_thread_text(self):
+        result = []
+        if not self._thread_messages:
+            result.append(("class:chat-thinking", "  Loading thread…\n"))
+            return result
+        for msg in self._thread_messages:
+            content  = msg.get("content") or msg.get("Content", "")
+            created  = msg.get("createdAt") or msg.get("CreatedAt", "")
+            msg_type = (msg.get("type") or msg.get("Type", "")).lower()
+            time_str = _fmt_time(created)
+
+            # Skip function/tool call messages — only show user prompts and AI answers
+            is_ai   = msg_type in ("ai-chat-answer", "ai-chat-answer2")
+            is_user = msg_type in ("ai-chat-prompt", "ai-chat-prompt2")
+            if not is_ai and not is_user:
+                continue
+
+            role_label = "  AI:  " if is_ai else "  You: "
+            role_style = "class:chat-ai" if is_ai else "class:chat-you"
+            body_style = "class:detail-body"
+
+            body = _strip_prefix(content) or content.strip()
+            if not body:
+                continue
+
+            result.append((role_style, role_label))
+            if time_str:
+                result.append(("class:msg-time", f"[{time_str}]\n"))
+            else:
+                result.append(("class:detail-body", "\n"))
+            for line in body.splitlines():
+                result.extend(_md_line_fragments(line, body_style))
+            result.append(("class:msg-time", "  " + "─" * 40 + "\n\n"))
+
+        if self._ai_thinking:
+            result.append(("class:chat-thinking", "  AI is thinking…\n"))
+        return result
+
+    def _build_detail_text(self):
+        result = []
+        if self._selected_index is None or not self._messages:
+            return result
+
+        msg     = self._messages[self._selected_index]
+        content = msg.get("content") or msg.get("Content", "")
+        created = msg.get("createdAt") or msg.get("CreatedAt", "")
+
+        tags     = _extract_tags(content)
+        body     = _strip_prefix(content)
+        time_str = _fmt_time(created)
+
+        if tags:
+            result.append(("class:detail-label", "  Tags: "))
+            result.append(("class:msg-tags", " ".join(f"#{t}" for t in tags) + "\n"))
+        if time_str:
+            result.append(("class:detail-label", "  Time: "))
+            result.append(("class:msg-time", time_str + "\n"))
+        result.append(("class:msg-time", "\n"))
+
+        if body:
+            resolved = _resolve_file_refs(body, self.codicent.base_url)
+            for line in resolved.splitlines():
+                if line.startswith("↓ "):
+                    result.append(("class:detail-label", "  "))
+                    result.append(("class:detail-url", line + "\n"))
+                else:
+                    result.extend(_md_line_fragments(line, "class:detail-body"))
+        else:
+            result.append(("class:msg-time", "  (no body)\n"))
+
+        return result
+
+    def _build_status_text(self):
+        mode_labels = {"ai-chat": "AI-CHAT", "thread": "THREAD", "detail": "DETAIL"}
+        if self._is_narrow():
+            project = (self.project or "")[:8]
+            pane    = "LOG" if self._narrow_active == "logbook" else "MSG"
+            hint    = "  [Tab] swap  [?] help  [Enter] send"
+            return [
+                ("class:status-key",  f" {project} "),
+                ("class:status-mode", f" {pane} "),
+                ("class:status-bar",  self._status_text),
+                ("class:status-bar",  hint),
+            ]
+        hint = (
+            "  [\u2191\u2193] navigate  [Esc] clear/deselect  "
+            "[Enter] send  [Ctrl+P] post  [Ctrl+J] spawn  "
+            "[Ctrl+N] new chat  [Ctrl+R] refresh  [?] help  [Ctrl+C] quit"
+        )
+        return [
+            ("class:status-key",  f" {self.project} "),
+            ("class:status-bar",  " │ "),
+            ("class:status-mode", f" {mode_labels.get(self._right_mode, '')} "),
+            ("class:status-bar",  " │ "),
+            ("class:status-bar",  self._status_text),
+            ("class:status-bar",  hint),
+        ]
+
+    def _right_panel_title(self):
+        if self._show_help:
+            return "Help"
+        return {"ai-chat": "Chat", "thread": "Thread", "detail": "Detail"}.get(
+            self._right_mode, "Chat"
+        )
+
+    # ------------------------------------------------------------------
+    # UI construction
+    # ------------------------------------------------------------------
+
+    def _build_ui(self):
+        # --- Left panel (Logbook) ---
+        self._messages_control = FormattedTextControl(
+            text=self._build_messages_text,
+            focusable=False,
+        )
+        messages_window = Window(
+            content=self._messages_control,
+            wrap_lines=True,
+            get_vertical_scroll=lambda win: self._messages_scroll_pos,
+        )
+        self._left_panel = Frame(messages_window, title="Logbook",
+                                 style="class:focused-frame")
+
+        # --- Right panel (frame only — no input nested inside) ---
+        self._right_control = FormattedTextControl(
+            text=self._build_right_panel_text,
+            focusable=False,
+        )
+        right_window = Window(
+            content=self._right_control,
+            wrap_lines=True,
+            get_vertical_scroll=lambda win: self._right_scroll_pos if self._right_manual_scroll else 9999,
+        )
+        self._right_panel = Frame(right_window, title=self._right_panel_title,
+                                  style="class:focused-frame")
+
+        # --- Input — lifted to root level so it stays visible in narrow mode
+        # regardless of which pane is showing. Single-line keeps Enter=send. ---
+        self.chat_input = TextArea(
+            prompt=self._input_prompt_text,
+            multiline=False,
+            height=1,
+            style="class:chat-input",
+            accept_handler=self._on_chat_accept,
+            focus_on_click=True,
+        )
+
+        # Cache the wide-mode body so DynamicContainer doesn't rebuild it every
+        # frame.
+        self._wide_body = VSplit([self._left_panel, self._right_panel], padding=1)
+
+        # --- Root ---
+        title_bar = Window(
+            content=FormattedTextControl(
+                lambda: [("class:title", f" Codicent TUI  @{self.project}")]
+            ),
+            height=1,
+            align=WindowAlign.LEFT,
+        )
+        status_bar = Window(
+            content=FormattedTextControl(text=self._build_status_text),
+            height=1,
+            style="class:status-bar",
+        )
+        body = DynamicContainer(self._get_body_container)
+        root = HSplit([title_bar, body, self.chat_input, status_bar])
+
+        self._layout = Layout(root, focused_element=self.chat_input)
+        self._kb     = self._build_keybindings()
+
+    def _get_body_container(self):
+        """Pick the body layout each render based on terminal width."""
+        if self._is_narrow():
+            return self._left_panel if self._narrow_active == "logbook" else self._right_panel
+        return self._wide_body
+
+    def _build_keybindings(self) -> KeyBindings:
+        kb = KeyBindings()
+
+        @kb.add("up")
+        def _up(event):
+            if not self.chat_input.text:
+                if self._selected_index is not None and self._selected_index == 0:
+                    event.app.output.bell()
+                else:
+                    self._move_selection(-1)
+            else:
+                # Input has text → scroll right panel instead
+                if not self._right_manual_scroll:
+                    self._right_manual_scroll = True
+                    self._right_scroll_pos = max(0, self._right_total_lines - 5)
+                self._right_scroll_pos = max(0, self._right_scroll_pos - 3)
+                self._refresh_display()
+
+        @kb.add("down")
+        def _down(event):
+            if not self.chat_input.text:
+                self._move_selection(1)
+            else:
+                if self._right_manual_scroll:
+                    self._right_scroll_pos += 3
+                    if self._right_scroll_pos >= max(0, self._right_total_lines - 2):
+                        self._right_manual_scroll = False
+                self._refresh_display()
+
+        @kb.add("escape")
+        def _escape(event):
+            if self._show_help:
+                self._show_help = False
+                self._refresh_display()
+            elif self.chat_input.text:
+                self.chat_input.text = ""
+            elif self._selected_index is not None:
+                self._clear_selection()
+
+        @kb.add("tab", filter=Condition(lambda: self._is_narrow()))
+        def _tab(event):
+            """Swap between Logbook and right pane in narrow mode."""
+            self._narrow_active = "logbook" if self._narrow_active == "right" else "right"
+            self._refresh_display()
+
+        @kb.add("?", filter=Condition(lambda: not self.chat_input.text))
+        def _help(event):
+            """Toggle help overlay (only when input is empty so '?' can be typed)."""
+            self._show_help = not self._show_help
+            if self._show_help and self._is_narrow():
+                self._narrow_active = "right"
+            self._refresh_display()
+
+        @kb.add("c-p")
+        def _ctrl_p(event):
+            text = self.chat_input.text
+            if text.strip():
+                self.chat_input.text = ""
+                parent_id = None
+                if self._right_mode == "detail" and self._selected_index is not None:
+                    msg = self._messages[self._selected_index]
+                    raw = msg.get("id") or msg.get("Id")
+                    parent_id = str(raw) if raw else None
+                threading.Thread(
+                    target=self._post_message, args=(text, parent_id), daemon=True
+                ).start()
+
+        @kb.add("c-n")
+        def _ctrl_n(event):
+            """Jump to new-chat mode from anywhere."""
+            self.chat_input.text = ""
+            self._clear_selection()
+
+        @kb.add("c-j")
+        def _ctrl_j(event):
+            text = self.chat_input.text
+            if text.strip():
+                self.chat_input.text = ""
+                threading.Thread(
+                    target=self._spawn_chat, args=(text,), daemon=True
+                ).start()
+
+        @kb.add("c-r")
+        def _ctrl_r(event):
+            threading.Thread(target=self._load_messages, daemon=True).start()
+
+        @kb.add("c-c")
+        def _ctrl_c(event):
+            event.app.exit()
+
+        return kb
+
+    # ------------------------------------------------------------------
+    # Accept handlers
+    # ------------------------------------------------------------------
+
+    def _on_chat_accept(self, buf: Buffer):
+        text = buf.text
+        stripped = text.strip()
+
+        # //foo escape → strip one slash and send the rest as plain text.
+        if stripped.startswith("//"):
+            text = text.replace("//", "/", 1)
+            stripped = text.strip()
+            # Fall through to normal send below.
+
+        # /command → dispatch table; consumes the input.
+        elif stripped.startswith("/"):
+            buf.reset()
+            self._handle_slash(stripped)
+            return True
+
+        if not stripped:
+            return True
+
+        buf.reset()
+
+        # Detail mode → post a child update of the selected message.
+        if self._right_mode == "detail" and self._selected_index is not None:
+            msg = self._messages[self._selected_index]
+            raw = msg.get("id") or msg.get("Id")
+            parent_id = str(raw) if raw else None
+            threading.Thread(
+                target=self._post_message, args=(text, parent_id), daemon=True
+            ).start()
+            return True
+
+        # ai-chat / thread → send to the AI conversation.
+        threading.Thread(
+            target=self._send_chat, args=(text,), daemon=True
+        ).start()
+        return True
+
+    def _handle_slash(self, cmd_text: str):
+        """Parse and dispatch a /command entered via the chat input.
+
+        Format: /word [optional body]. The body becomes the message for /post,
+        /spawn, and /new (when applicable)."""
+        cmd, _, body = cmd_text[1:].partition(" ")
+        cmd = cmd.lower().strip()
+        body = body.strip()
+
+        if cmd == "post":
+            parent_id = None
+            if self._right_mode == "detail" and self._selected_index is not None:
+                msg = self._messages[self._selected_index]
+                raw = msg.get("id") or msg.get("Id")
+                parent_id = str(raw) if raw else None
+            if not body:
+                self._status_text = "Usage: /post <text>"
+                self._refresh_display()
+                return
+            threading.Thread(
+                target=self._post_message, args=(body, parent_id), daemon=True
+            ).start()
+
+        elif cmd == "spawn":
+            if not body:
+                self._status_text = "Usage: /spawn <text>"
+                self._refresh_display()
+                return
+            threading.Thread(
+                target=self._spawn_chat, args=(body,), daemon=True
+            ).start()
+
+        elif cmd == "new":
+            self._clear_selection()
+            if body:
+                threading.Thread(
+                    target=self._send_chat, args=(body,), daemon=True
+                ).start()
+
+        elif cmd == "refresh":
+            threading.Thread(target=self._load_messages, daemon=True).start()
+
+        elif cmd in ("help", "?"):
+            self._show_help = not self._show_help
+            if self._show_help and self._is_narrow():
+                self._narrow_active = "right"
+            self._refresh_display()
+
+        elif cmd == "quit":
+            try:
+                self._app.exit()
+            except Exception:
+                pass
+
+        else:
+            self._status_text = f"Unknown command: /{cmd}"
+            self._refresh_display()
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _refresh_display(self):
+        try:
+            self._app.invalidate()
+        except Exception:
+            pass
+
+    # ------------------------------------------------------------------
+    # Entry point
+    # ------------------------------------------------------------------
+
+    def run(self):
+        app_input, app_output = _create_prompt_io()
+        self._app = Application(
+            layout=self._layout,
+            key_bindings=self._kb,
+            style=STYLE,
+            full_screen=True,
+            mouse_support=True,
+            input=app_input,
+            output=app_output,
+        )
+        threading.Thread(target=self._load_messages, daemon=True).start()
+        self._app.run()
+
+def run_tui(codicent, project: str):
+    """Entry point called from app.py."""
+    CodicentTUI(codicent, project).run()