chad-console 0.1.0__py3-none-any.whl

chad_console-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: chad-console
+Version: 0.1.0
+Summary: Intercepts print() and input() calls, routing them to a beautiful dark-mode GUI console.
+Project-URL: Homepage, https://github.com/m-ali04/chad-console
+Project-URL: Repository, https://github.com/m-ali04/chad-console
+Project-URL: Issues, https://github.com/m-ali04/chad-console/issues
+Author-email: m-ali04 <m-ali04@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: chad-console,console,customtkinter,developer-tools,gui,pretty-print
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.12
+Requires-Dist: customtkinter>=5.2
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ✦ ChadConsole
+
+> Intercepts `print()` and `input()` — routes them to a beautiful dark-mode GUI.
+
+## Installation
+
+```bash
+pip install chadconsole
+```
+
+## Usage
+
+```python
+import chadconsole  # That's it. All prints now go to the GUI.
+
+print("Hello, world!")
+print({"key": "value", "nested": [1, 2, 3]})
+
+for i in range(5):
+    print("*" * (i + 1))
+
+name = input("What's your name? ")
+print(f"Welcome, {name}!")
+```
+
+## Features
+
+- **Zero config** — just `import chadconsole` at the top of your script
+- **Auto type detection** — lists, dicts, tuples get special formatted rendering
+- **Loop grouping** — `print()` calls inside `for` loops are automatically batched into a single visual block (bytecode-based detection, no `time.sleep()` needed)
+- **Input interception** — `input()` calls display a floating entry field in the GUI
+- **Dark neumorphic UI** — premium design with blue accents and monospace code rendering
+- **Thread-safe** — your script runs normally; the GUI runs in a background thread
+
+## License
+
+MIT

chad_console-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+chadconsole/__init__.py,sha256=ncnH2Dj1Y9mDLahJJSSc-H4iwqlbIu4IjPY0iK9Qj3U,2613
+chadconsole/core_interceptor.py,sha256=JurD1j66pcKwXrKt9_Kn0AEYQggsInLhpuYr5twP3GI,13245
+chadconsole/data_analyzer.py,sha256=4Zx0yLxcSyD1JjEyBdHSQ9WU5eayS0cCU4IGEo5O-os,3072
+chadconsole/ui_components.py,sha256=rOf_FXFvPJLg4LewvUS6z3mxsmG1ASg-7UJg-_R1FWo,14453
+chadconsole/ui_engine.py,sha256=_nEvyXDX8zkxkaS_A7adJwfkVuBYxUK7vrYqbK8DSRQ,10699
+chadconsole/assets/logo.png,sha256=Gc1zW-mumiYsqRcAa66ejMGkQ-jKEUWg1xZ8zHSESi0,257314
+chad_console-0.1.0.dist-info/METADATA,sha256=zWGoMHsbdla0kcRP5W8U005H32W5_IpXSmXPxWf-pnU,2347
+chad_console-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+chad_console-0.1.0.dist-info/licenses/LICENSE,sha256=Pkuua4s8oOqYuuNcR-OCMhrsdMtcFKryxaaWBD8Ab-A,1081
+chad_console-0.1.0.dist-info/RECORD,,

chad_console-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

chad_console-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ali
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chadconsole/__init__.py

@@ -0,0 +1,79 @@
+"""
+chadconsole
+~~~~~~~~~~~
+
+Just ``import chadconsole`` and all your print() and input() calls
+are routed to a beautiful dark-mode GUI window.
+
+Architecture:
+    1. A shared queue.Queue connects the script thread to the UI thread.
+    2. core_interceptor replaces sys.stdout, builtins.print, builtins.input.
+    3. ui_engine.PrettyConsoleApp runs Tk mainloop in a NON-daemon thread
+       so the window stays alive even after the user's script finishes.
+    4. The user's script continues executing on the main thread.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+__all__: list[str] = []
+
+import atexit
+import os
+import queue
+import sys
+import threading
+
+from chadconsole.core_interceptor import install, uninstall
+from chadconsole.ui_engine import PrettyConsoleApp
+
+
+# ---------------------------------------------------------------------------
+# Shared communication channel
+# ---------------------------------------------------------------------------
+
+_output_queue: queue.Queue = queue.Queue()
+
+# ---------------------------------------------------------------------------
+# Install interceptors
+# ---------------------------------------------------------------------------
+
+_input_handler = install(_output_queue)
+
+# ---------------------------------------------------------------------------
+# Launch the UI in a NON-daemon thread (keeps process alive until window closes)
+# ---------------------------------------------------------------------------
+
+_app: PrettyConsoleApp | None = None
+_ui_ready = threading.Event()
+
+
+def _run_ui() -> None:
+    """Entry point for the UI thread.
+
+    This is a NON-daemon thread so the window stays open even after the
+    user's main script finishes executing. The process exits only when
+    the user closes the GUI window.
+    """
+    global _app
+    try:
+        _app = PrettyConsoleApp(_output_queue)
+        _app.set_input_handler(_input_handler)
+        _ui_ready.set()
+        _app.mainloop()
+    except Exception:
+        import traceback
+        sys.__stderr__.write(f"[ChadConsole] UI thread crashed:\n{traceback.format_exc()}\n")
+        _ui_ready.set()  # Unblock main thread even on failure
+    finally:
+        # When the window is closed (mainloop exits), clean up and exit
+        uninstall()
+        os._exit(0)  # Clean exit — suppresses Tcl_AsyncDelete noise
+
+
+# NON-daemon thread: process stays alive until this thread ends (window closed)
+_ui_thread = threading.Thread(target=_run_ui, daemon=False, name="ChadConsole-UI")
+_ui_thread.start()
+
+# Wait for the UI to be ready before the script proceeds
+_ui_ready.wait(timeout=5.0)

chadconsole/core_interceptor.py

@@ -0,0 +1,351 @@
+"""
+chadconsole.core_interceptor
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Hijacks sys.stdout, builtins.print, and builtins.input to route all I/O
+through a thread-safe queue to the PrettyConsole UI.
+
+Key features:
+- ConsoleWriter replaces sys.stdout (captures raw write() calls)
+- custom_print replaces builtins.print with structural loop detection
+- custom_input replaces builtins.input (blocks caller, signals UI for input field)
+
+Loop Detection Strategy (bytecode-based, no timers needed):
+    On each print() call, we inspect the caller's call-stack frames using
+    ``dis.get_instructions()`` to check whether the print was called from
+    inside a ``for`` loop body.
+
+    For each frame we:
+      1. Collect all ``FOR_ITER`` instructions and their loop-end offsets.
+      2. Collect all ``JUMP_BACKWARD`` instructions and which ``FOR_ITER`` they
+         jump back to.
+      3. If the frame's ``f_lasti`` (last executed bytecode offset) falls
+         within [FOR_ITER+2 .. JUMP_BACKWARD], we are in a loop body.
+      4. Return a key ``(filename, code_id, for_iter_offset)`` that uniquely
+         identifies this specific loop.
+
+    Consecutive prints sharing the same key are accumulated into a single
+    buffer and emitted as one ``loop_pattern`` payload when the key changes
+    or a non-loop print arrives.
+
+    Prints that are NOT inside any loop → emitted immediately, zero latency.
+    No ``time.sleep()`` required anywhere in user code.
+"""
+
+from __future__ import annotations
+
+import builtins
+import dis
+import opcode
+import queue
+import sys
+import threading
+from typing import Any, TextIO
+
+from chadconsole.data_analyzer import ErrorPayload, InputRequest, Payload, analyze
+
+
+# ---------------------------------------------------------------------------
+# Bytecode constants (resolved once at import time for this Python version)
+# ---------------------------------------------------------------------------
+
+_FOR_ITER     = opcode.opmap.get("FOR_ITER")
+_JUMP_BACKWARD = opcode.opmap.get("JUMP_BACKWARD")
+
+
+# ---------------------------------------------------------------------------
+# Loop detection helpers
+# ---------------------------------------------------------------------------
+
+def _is_frame_in_for_loop(frame) -> tuple | None:
+    """Check if *frame* is currently executing inside a ``for`` loop body.
+
+    Returns a hashable key ``(filename, code_obj_id, for_iter_offset)``
+    uniquely identifying this loop, or ``None`` if the frame is not in a loop.
+    """
+    if _FOR_ITER is None or _JUMP_BACKWARD is None:
+        return None  # Unsupported Python version — degrade gracefully
+
+    code = frame.f_code
+    current_offset = frame.f_lasti
+
+    try:
+        instructions = list(dis.get_instructions(code))
+    except Exception:
+        return None
+
+    # Map: FOR_ITER.offset  -> END_FOR offset (via FOR_ITER.argval)
+    # Map: FOR_ITER.offset  -> JUMP_BACKWARD.offset (who jumps back here)
+    for_iters: dict[int, int] = {}   # for_iter_offset -> end_for_offset
+    jump_backs: dict[int, int] = {}  # for_iter_offset -> jump_backward_offset
+
+    for instr in instructions:
+        if instr.opcode == _FOR_ITER:
+            for_iters[instr.offset] = instr.argval   # argval = END_FOR target
+        elif instr.opcode == _JUMP_BACKWARD:
+            # argval is the target offset (the FOR_ITER we jump back to)
+            jump_backs[instr.argval] = instr.offset
+
+    for for_iter_off, end_for_off in for_iters.items():
+        jump_back_off = jump_backs.get(for_iter_off)
+        if jump_back_off is None:
+            continue
+        # Loop body occupies instructions from (for_iter_off + 2) to jump_back_off
+        body_start = for_iter_off + 2
+        body_end   = jump_back_off
+        if body_start <= current_offset <= body_end:
+            return (code.co_filename, id(code), for_iter_off)
+
+    return None
+
+
+def _caller_loop_key(skip: int = 2) -> tuple | None:
+    """Walk the call stack starting *skip* frames up and find the first
+    frame that is executing inside a ``for`` loop.
+
+    Returns the loop key, or ``None`` if no enclosing loop is found.
+    We search up to 8 frames deep to handle prints inside helper functions
+    that are called from within a loop.
+    """
+    try:
+        frame = sys._getframe(skip)
+    except ValueError:
+        return None
+
+    for _ in range(8):
+        if frame is None:
+            break
+        key = _is_frame_in_for_loop(frame)
+        if key is not None:
+            return key
+        frame = frame.f_back
+
+    return None
+
+
+# ---------------------------------------------------------------------------
+# ConsoleWriter — replacement for sys.stdout
+# ---------------------------------------------------------------------------
+
+class ConsoleWriter:
+    """A file-like object that captures direct sys.stdout.write() calls.
+
+    Any code doing ``sys.stdout.write(...)`` directly (e.g. logging, third-party
+    libs) is captured here and emitted as a standard payload immediately.
+    """
+
+    def __init__(self, output_queue: queue.Queue, original: TextIO) -> None:
+        self._queue = output_queue
+        self._original = original
+        self.encoding = getattr(original, "encoding", "utf-8")
+
+    def write(self, text: str) -> int:
+        """Capture direct stdout writes as standard payloads."""
+        if text and text.strip():
+            payload = Payload(tag="standard", content=text.rstrip("\n"))
+            self._queue.put(payload)
+        return len(text)
+
+    def flush(self) -> None:
+        """No-op — the GUI doesn't need flushing."""
+
+    def fileno(self) -> int:
+        """Delegate to original stdout for compatibility."""
+        return self._original.fileno()
+
+    def isatty(self) -> bool:
+        return False
+
+
+# ---------------------------------------------------------------------------
+# LoopGrouper — structural, deterministic loop grouping
+# ---------------------------------------------------------------------------
+
+class _LoopGrouper:
+    """Groups consecutive print() calls that originate from the SAME ``for`` loop.
+
+    Algorithm:
+    1. On each print(), inspect the call stack to get a ``loop_key``.
+    2. ``loop_key is None``  → not in a loop → flush any pending buffer, emit immediately.
+    3. ``loop_key == self._current_key`` → same loop, same iteration → append to buffer.
+    4. ``loop_key != self._current_key`` → new/different loop → flush old buffer, start new.
+
+    When the buffer is flushed, it becomes a single ``loop_pattern`` Payload.
+
+    Thread-safe via a Lock (multiple threads can call print() concurrently).
+    """
+
+    def __init__(self, output_queue: queue.Queue) -> None:
+        self._queue = output_queue
+        self._lock = threading.Lock()
+        self._buffer: list[str] = []
+        self._current_key: tuple | None = None
+
+    def submit(self, payload: Payload) -> None:
+        """Route a payload — either buffer it (loop) or emit immediately (non-loop)."""
+        # skip=3: submit() → custom_print() → caller's frame
+        loop_key = _caller_loop_key(skip=3)
+
+        with self._lock:
+            if loop_key is None:
+                # ── Not in a for-loop ─────────────────────────────────
+                self._flush_locked()
+                self._queue.put(payload)
+
+            elif loop_key == self._current_key:
+                # ── Same loop — accumulate ────────────────────────────
+                self._buffer.append(payload.content)
+
+            else:
+                # ── New loop (or first loop print) ────────────────────
+                self._flush_locked()
+                self._current_key = loop_key
+                self._buffer.append(payload.content)
+
+    def flush(self) -> None:
+        """Public flush — call this before input() or at script end."""
+        with self._lock:
+            self._flush_locked()
+
+    def _flush_locked(self) -> None:
+        """Emit buffer as a single loop_pattern payload. Must hold ``_lock``."""
+        if not self._buffer:
+            self._current_key = None
+            return
+        content = "\n".join(self._buffer)
+        self._buffer.clear()
+        self._current_key = None
+        self._queue.put(Payload(tag="loop_pattern", content=content))
+
+
+# ---------------------------------------------------------------------------
+# Input handler
+# ---------------------------------------------------------------------------
+
+class _InputHandler:
+    """Manages the input() interception lifecycle.
+
+    When input() is called:
+    1. Flush any pending loop buffer (so loop output appears before the prompt).
+    2. Push an InputRequest to the queue (tells UI to show entry field).
+    3. Block the calling thread on a threading.Event.
+    4. The UI calls .resolve(value) when the user hits Enter.
+    5. The Event is released and the value is returned to the caller.
+    """
+
+    def __init__(self, output_queue: queue.Queue, grouper: _LoopGrouper) -> None:
+        self._queue = output_queue
+        self._grouper = grouper
+        self._event = threading.Event()
+        self._response: str = ""
+        self._lock = threading.Lock()
+
+    def request(self, prompt: str = "") -> str:
+        """Called from the user's script thread — blocks until UI responds."""
+        # Flush loop buffer so loop output isn't stuck behind the prompt
+        self._grouper.flush()
+
+        with self._lock:
+            self._event.clear()
+            self._response = ""
+
+        # Signal the UI
+        req = InputRequest(prompt=prompt, handler=self)
+        self._queue.put(req)
+
+        # Block until the UI resolves
+        self._event.wait()
+        return self._response
+
+    def resolve(self, value: str) -> None:
+        """Called from the UI thread when the user submits input."""
+        self._response = value
+        self._event.set()
+
+
+# ---------------------------------------------------------------------------
+# Installer — wires everything up
+# ---------------------------------------------------------------------------
+
+_original_print     = builtins.print
+_original_input     = builtins.input
+_original_stdout    = sys.stdout
+_original_excepthook = sys.excepthook
+
+
+def install(output_queue: queue.Queue) -> _InputHandler:
+    """Install all interceptors. Returns the InputHandler for UI wiring.
+
+    Call this once during chadconsole initialization.
+    """
+    # 1. Replace sys.stdout
+    writer = ConsoleWriter(output_queue, _original_stdout)
+    sys.stdout = writer  # type: ignore[assignment]
+
+    # 2. Build the loop grouper (structural, zero-latency, no timers)
+    grouper = _LoopGrouper(output_queue)
+
+    # Flush any buffered loop output when the user's script finishes.
+    # Without this, a for-loop at the END of a script (or as the ONLY thing)
+    # would never flush — the output would be silently lost.
+    #
+    # Why not atexit?  atexit handlers only fire after ALL non-daemon threads
+    # finish, but the UI thread is non-daemon (so it blocks atexit).  And when
+    # the window closes, os._exit(0) skips atexit entirely.
+    #
+    # Solution: a tiny daemon thread that waits for the main thread to end,
+    # then flushes the grouper.  The data lands in the queue and the UI thread
+    # (still alive) picks it up and renders it.
+    def _flush_on_main_exit() -> None:
+        threading.main_thread().join()
+        grouper.flush()
+
+    threading.Thread(
+        target=_flush_on_main_exit, daemon=True, name="ChadConsole-Flush"
+    ).start()
+
+    # 3. Replace builtins.print
+    def custom_print(*args: Any, sep: str = " ", end: str = "\n", **kwargs: Any) -> None:
+        """Loop-aware, zero-latency print() replacement."""
+        payload = analyze(*args, sep=sep)
+        grouper.submit(payload)
+
+    builtins.print = custom_print  # type: ignore[assignment]
+
+    # 4. Replace builtins.input
+    handler = _InputHandler(output_queue, grouper)
+
+    def custom_input(prompt: str = "") -> str:
+        """Blocking input() replacement — signals UI for entry field."""
+        return handler.request(prompt)
+
+    builtins.input = custom_input  # type: ignore[assignment]
+
+    # 5. Install sys.excepthook to catch ALL unhandled exceptions
+    #    and display them as red ErrorBlocks in the GUI.
+    import traceback as _tb
+
+    def custom_excepthook(exc_type, exc_value, exc_tb) -> None:
+        """Intercept unhandled exceptions — flush loop buffer then send ErrorPayload."""
+        # Flush any buffered loop lines so they appear before the error
+        grouper.flush()
+        # Format the full traceback text
+        full_tb = "".join(_tb.format_exception(exc_type, exc_value, exc_tb)).rstrip()
+        err = ErrorPayload(
+            error_type=exc_type.__name__,
+            message=str(exc_value),
+            traceback=full_tb,
+        )
+        output_queue.put(err)
+
+    sys.excepthook = custom_excepthook
+
+    return handler
+
+
+def uninstall() -> None:
+    """Restore original print, input, stdout, and excepthook."""
+    builtins.print = _original_print
+    builtins.input = _original_input
+    sys.stdout     = _original_stdout
+    sys.excepthook = _original_excepthook

chadconsole/data_analyzer.py

@@ -0,0 +1,90 @@
+"""
+chadconsole.data_analyzer
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Inspects raw print() arguments, detects their types, formats structured
+data with pprint, and returns tagged Payload objects for the UI layer.
+
+Tags:
+    "standard"      — plain text (str, int, float, bool, etc.)
+    "list"          — a list object
+    "dictionary"    — a dict object
+    "tuple"         — a tuple object
+    "loop_pattern"  — multiple lines from a loop (grouped by core_interceptor)
+    "input"         — signals the UI to show an entry field (InputRequest)
+    "error"         — unhandled exception (ErrorPayload)
+"""
+
+from __future__ import annotations
+
+import pprint
+from dataclasses import dataclass, field
+from typing import Any
+
+
+# ---------------------------------------------------------------------------
+# Payload — the single data unit that flows through the queue
+# ---------------------------------------------------------------------------
+
+@dataclass(slots=True)
+class Payload:
+    """A tagged chunk of output destined for the UI."""
+
+    tag: str        # "standard" | "list" | "dictionary" | "tuple" | "loop_pattern"
+    content: str    # The formatted string to display
+
+
+@dataclass(slots=True)
+class InputRequest:
+    """Signals the UI to show an input entry field."""
+
+    prompt: str
+    handler: Any = None
+
+
+@dataclass(slots=True)
+class ErrorPayload:
+    """Signals the UI to display a red error block for an unhandled exception."""
+
+    error_type: str          # e.g. "NameError", "ZeroDivisionError", "SyntaxError"
+    message: str             # str(exception) — the short human-readable message
+    traceback: str = ""      # Full formatted traceback (empty for simple stderr errors)
+
+
+# ---------------------------------------------------------------------------
+# Tag mapping — structural types only
+# ---------------------------------------------------------------------------
+
+_TYPE_TAG_MAP: dict[type, str] = {
+    list:  "list",
+    dict:  "dictionary",
+    tuple: "tuple",
+}
+
+_PRETTY_PRINTER = pprint.PrettyPrinter(indent=2, width=80, sort_dicts=False)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def analyze(*args: Any, sep: str = " ") -> Payload:
+    """Inspect raw print() arguments and return a tagged Payload.
+
+    Strategy:
+    - Exactly ONE argument that is a list, dict, or tuple → structured tag + pformat.
+    - Everything else → join with *sep* and tag as "standard".
+
+    Note: loop detection is handled upstream in core_interceptor, NOT here.
+    This function is purely about *what* is being printed, not *how many times*.
+    """
+    if len(args) == 1:
+        obj = args[0]
+        tag = _TYPE_TAG_MAP.get(type(obj))
+        if tag is not None:
+            content = _PRETTY_PRINTER.pformat(obj)
+            return Payload(tag=tag, content=content)
+
+    # Fallback: join everything as plain text
+    content = sep.join(str(a) for a in args)
+    return Payload(tag="standard", content=content)

chadconsole/ui_components.py

@@ -0,0 +1,445 @@
+"""
+chadconsole.ui_components
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Custom CTkFrame-based visual blocks for each output type.
+Every component is packed with pady=15 for distinct visual spacing.
+
+Design: Dark neumorphic with deep blue accents and purple loop containers.
+"""
+
+from __future__ import annotations
+
+import customtkinter as ctk
+
+
+# ---------------------------------------------------------------------------
+# Color Palette — Dark Neumorphic Blue
+# ---------------------------------------------------------------------------
+
+class Colors:
+    """Centralized color tokens for the entire UI."""
+
+    BG_MAIN       = "#0D1117"   # Deep dark background
+    BG_CARD_NAVBAR = "#0c0e12"   # Card / frame background
+    BG_CARD       = "#161B22"   # Card / frame background
+    BG_CARD_ALT   = "#1C2333"   # Alternate card — structured data
+    BG_LOOP       = "#1A1232"   # Loop container — purple-tinted dark
+    BG_INPUT      = "#0F1923"   # Input block background
+
+    ACCENT_BLUE   = "#58A6FF"   # Primary accent — borders, cursor, highlights
+    ACCENT_PURPLE = "#8B5CF6"   # Loop container border & accent
+    ACCENT_GREEN  = "#3FB950"   # Success / type badges
+    ACCENT_AMBER  = "#D29922"   # Warning / tuple badge
+
+    TEXT_PRIMARY   = "#E6EDF3"   # Main text
+    TEXT_SECONDARY = "#8B949E"   # Timestamps, labels
+    TEXT_MONO      = "#79C0FF"   # Monospace text in loop containers
+    TEXT_DIM       = "#484F58"   # Very subtle text
+
+    BORDER_SUBTLE  = "#30363D"   # Subtle card borders
+    BORDER_BLUE    = "#1F6FEB"   # Blue accent border
+    BORDER_PURPLE  = "#6D28D9"   # Purple accent border (loops)
+    BORDER_RED     = "#7B1A1A"   # Error block inner border
+
+    ACCENT_RED     = "#FF6B6B"   # Error accent — badge, left bar
+    BG_ERROR       = "#160A0A"   # Error block background (dark blood-red tint)
+    TEXT_ERROR     = "#FF8585"   # Error message / traceback text
+
+    INPUT_BG       = "#0D1117"   # Entry field background
+    INPUT_BORDER   = "#58A6FF"   # Entry field border
+
+
+# ---------------------------------------------------------------------------
+# Font constants
+# ---------------------------------------------------------------------------
+
+FONT_BODY      = ("Inter", 14)
+FONT_BODY_BOLD = ("Inter", 14, "bold")
+FONT_MONO      = ("Consolas", 13)
+FONT_MONO_LG   = ("Consolas", 14)
+FONT_BADGE     = ("Inter", 11, "bold")
+FONT_LABEL     = ("Inter", 12)
+FONT_HEADER    = ("Inter", 16, "bold")
+FONT_TITLE     = ("Inter", 16, "bold")
+
+
+# ---------------------------------------------------------------------------
+# Base Block
+# ---------------------------------------------------------------------------
+
+class _BaseBlock(ctk.CTkFrame):
+    """Base class for all output blocks.
+
+    Provides consistent card styling with a colored left accent border.
+    """
+
+    PACK_PADY = 8  # Enforced gap between blocks
+
+    def __init__(
+        self,
+        master: ctk.CTkBaseClass,
+        accent_color: str = Colors.ACCENT_BLUE,
+        bg_color: str = Colors.BG_CARD,
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            master,
+            fg_color=bg_color,
+            corner_radius=10,
+            border_width=0,
+            **kwargs,
+        )
+
+        # Outer container with left accent stripe
+        self._accent_bar = ctk.CTkFrame(
+            self,
+            fg_color=accent_color,
+            width=4,
+            height=0,
+            corner_radius=2,
+        )
+        self._accent_bar.pack(side="left", fill="y", padx=(0, 0), pady=4)
+
+        # Content area
+        self._content = ctk.CTkFrame(self, fg_color="transparent")
+        self._content.pack(side="left", fill="both", expand=False, padx=(12, 16), pady=4)
+
+    def pack(self, **kwargs) -> None:
+        """Override pack to enforce the required 15px vertical gap."""
+        kwargs.setdefault("pady", self.PACK_PADY)
+        kwargs.setdefault("padx", 16)
+        kwargs.setdefault("anchor", "w")
+        super().pack(**kwargs)
+
+
+# ---------------------------------------------------------------------------
+# StandardBlock — plain text output
+# ---------------------------------------------------------------------------
+
+class StandardBlock(_BaseBlock):
+    """Renders standard text output in a clean card."""
+
+    def __init__(self, master: ctk.CTkBaseClass, text: str, **kwargs) -> None:
+        super().__init__(master, accent_color=Colors.ACCENT_BLUE, bg_color=Colors.BG_CARD, **kwargs)
+
+        label = ctk.CTkLabel(
+            self._content,
+            text=text,
+            font=FONT_BODY,
+            text_color=Colors.TEXT_PRIMARY,
+            anchor="w",
+            justify="left",
+            wraplength=600,
+        )
+        label.pack(fill="x", anchor="w")
+
+
+# ---------------------------------------------------------------------------
+# StructuredBlock — list, dict, tuple
+# ---------------------------------------------------------------------------
+
+# Badge colors per type
+_BADGE_STYLES: dict[str, tuple[str, str]] = {
+    "list":       (Colors.ACCENT_BLUE,  "LIST"),
+    "dictionary": (Colors.ACCENT_GREEN, "DICT"),
+    "tuple":      (Colors.ACCENT_AMBER, "TUPLE"),
+}
+
+
+class StructuredBlock(_BaseBlock):
+    """Renders structured data (list/dict/tuple) with a type badge
+    and monospace formatted content.
+    """
+
+    def __init__(
+        self,
+        master: ctk.CTkBaseClass,
+        text: str,
+        data_type: str = "dictionary",
+        **kwargs,
+    ) -> None:
+        badge_color, badge_label = _BADGE_STYLES.get(data_type, (Colors.ACCENT_BLUE, "DATA"))
+        super().__init__(master, accent_color=badge_color, bg_color=Colors.BG_CARD_ALT, **kwargs)
+
+        # Type badge
+        badge_frame = ctk.CTkFrame(
+            self._content,
+            fg_color=badge_color,
+            corner_radius=6,
+            height=22,
+        )
+        badge_frame.pack(anchor="w", pady=(0, 8))
+
+        badge_text = ctk.CTkLabel(
+            badge_frame,
+            text=f"  {badge_label}  ",
+            font=FONT_BADGE,
+            text_color=Colors.BG_MAIN,
+            height=22,
+        )
+        badge_text.pack(padx=2, pady=1)
+
+        # Formatted content in monospace
+        content_frame = ctk.CTkFrame(
+            self._content,
+            fg_color=Colors.BG_CARD,
+            corner_radius=8,
+            border_width=1,
+            border_color=Colors.BORDER_SUBTLE,
+        )
+        content_frame.pack(fill="x", pady=(0, 0))
+
+        content_label = ctk.CTkLabel(
+            content_frame,
+            text=text,
+            font=FONT_MONO,
+            text_color=Colors.TEXT_PRIMARY,
+            anchor="nw",
+            justify="left",
+            wraplength=580,
+        )
+        content_label.pack(fill="x", padx=12, pady=10, anchor="w")
+
+
+# ---------------------------------------------------------------------------
+# LoopPatternBlock — grouped rapid-fire prints
+# ---------------------------------------------------------------------------
+
+class LoopPatternBlock(_BaseBlock):
+    """Renders grouped loop output in a distinct purple-accented container
+    with strict monospace font for perfect ASCII alignment.
+    """
+
+    def __init__(self, master: ctk.CTkBaseClass, text: str, **kwargs) -> None:
+        super().__init__(
+            master,
+            accent_color=Colors.ACCENT_PURPLE,
+            bg_color=Colors.BG_LOOP,
+            **kwargs,
+        )
+
+        # Header badge
+        header_frame = ctk.CTkFrame(self._content, fg_color="transparent")
+        header_frame.pack(fill="x", pady=(0, 8))
+
+        badge = ctk.CTkFrame(
+            header_frame,
+            fg_color=Colors.ACCENT_PURPLE,
+            corner_radius=6,
+            height=22,
+        )
+        badge.pack(side="left")
+
+        badge_label = ctk.CTkLabel(
+            badge,
+            text="  LOOP OUTPUT  ",
+            font=FONT_BADGE,
+            text_color="#FFFFFF",
+            height=22,
+        )
+        badge_label.pack(padx=2, pady=1)
+
+        # Line count indicator
+        line_count = text.count("\n") + 1
+        count_label = ctk.CTkLabel(
+            header_frame,
+            text=f"{line_count} lines",
+            font=FONT_LABEL,
+            text_color=Colors.TEXT_SECONDARY,
+        )
+        count_label.pack(side="left", padx=(10, 0))
+
+        # Monospace content area
+        mono_frame = ctk.CTkFrame(
+            self._content,
+            fg_color="#0D0D1A",
+            corner_radius=8,
+            border_width=1,
+            border_color=Colors.BORDER_PURPLE,
+        )
+        mono_frame.pack(fill="x")
+
+        mono_label = ctk.CTkLabel(
+            mono_frame,
+            text=text,
+            font=FONT_MONO_LG,
+            text_color=Colors.TEXT_MONO,
+            anchor="nw",
+            justify="left",
+        )
+        mono_label.pack(fill="x", padx=14, pady=12, anchor="w")
+
+
+# ---------------------------------------------------------------------------
+# InputBlock — floating input entry field
+# ---------------------------------------------------------------------------
+
+class InputBlock(_BaseBlock):
+    """Renders an input prompt with an entry field.
+
+    When the user presses Enter, calls the provided callback with the value.
+    """
+
+    def __init__(
+        self,
+        master: ctk.CTkBaseClass,
+        prompt: str = "",
+        on_submit: callable = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            master,
+            accent_color=Colors.ACCENT_BLUE,
+            bg_color=Colors.BG_INPUT,
+            **kwargs,
+        )
+        self._on_submit = on_submit
+        self._submitted = False
+
+        # Prompt label
+        if prompt:
+            prompt_label = ctk.CTkLabel(
+                self._content,
+                text=prompt,
+                font=FONT_BODY_BOLD,
+                text_color=Colors.ACCENT_BLUE,
+                anchor="w",
+            )
+            prompt_label.pack(fill="x", pady=(0, 8))
+
+        # Input row: entry + submit button
+        input_row = ctk.CTkFrame(self._content, fg_color="transparent")
+        input_row.pack(fill="x")
+
+        self._entry = ctk.CTkEntry(
+            input_row,
+            font=FONT_MONO,
+            fg_color=Colors.INPUT_BG,
+            text_color=Colors.TEXT_PRIMARY,
+            border_color=Colors.INPUT_BORDER,
+            border_width=2,
+            corner_radius=8,
+            height=40,
+            placeholder_text="Type here and press Enter...",
+            placeholder_text_color=Colors.TEXT_DIM,
+        )
+        self._entry.pack(side="left", fill="x", expand=True, padx=(0, 8))
+        self._entry.bind("<Return>", self._handle_submit)
+
+        self._submit_btn = ctk.CTkButton(
+            input_row,
+            text="Submit",
+            font=FONT_BADGE,
+            fg_color=Colors.ACCENT_BLUE,
+            hover_color=Colors.BORDER_BLUE,
+            text_color="#FFFFFF",
+            corner_radius=8,
+            width=80,
+            height=40,
+            command=lambda: self._handle_submit(None),
+        )
+        self._submit_btn.pack(side="right")
+
+        # Auto-focus the entry
+        self._entry.after(100, self._entry.focus_set)
+
+    def _handle_submit(self, event) -> None:
+        """Handle Enter key or button click."""
+        if self._submitted:
+            return
+        self._submitted = True
+
+        value = self._entry.get()
+
+        # Visual feedback: disable entry, change accent to green
+        self._entry.configure(state="disabled", border_color=Colors.ACCENT_GREEN)
+        self._submit_btn.configure(state="disabled", fg_color=Colors.BORDER_SUBTLE)
+        self._accent_bar.configure(fg_color=Colors.ACCENT_GREEN)
+
+        if self._on_submit:
+            self._on_submit(value)
+
+
+# ---------------------------------------------------------------------------
+# ErrorBlock — unhandled exception display
+# ---------------------------------------------------------------------------
+
+class ErrorBlock(_BaseBlock):
+    """Renders an unhandled exception as a red-accented error card.
+
+    Shows:
+    - A red badge with the exception type (e.g. "NameError")
+    - The short error message in bold
+    - The full traceback in a dark monospace code box (when available)
+    """
+
+    def __init__(
+        self,
+        master: ctk.CTkBaseClass,
+        error_type: str,
+        message: str,
+        traceback: str = "",
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            master,
+            accent_color=Colors.ACCENT_RED,
+            bg_color=Colors.BG_ERROR,
+            **kwargs,
+        )
+
+        # ── Error type badge ───────────────────────────────────────────
+        header_row = ctk.CTkFrame(self._content, fg_color="transparent")
+        header_row.pack(fill="x", pady=(0, 8))
+
+        badge_frame = ctk.CTkFrame(
+            header_row,
+            fg_color=Colors.ACCENT_RED,
+            corner_radius=6,
+            height=22,
+        )
+        badge_frame.pack(side="left")
+
+        badge_text = ctk.CTkLabel(
+            badge_frame,
+            text=f"  ✕  {error_type}  ",
+            font=FONT_BADGE,
+            text_color="#FFFFFF",
+            height=22,
+        )
+        badge_text.pack(padx=2, pady=1)
+
+        # ── Error message ──────────────────────────────────────────────
+        if message:
+            msg_label = ctk.CTkLabel(
+                self._content,
+                text=message,
+                font=FONT_BODY_BOLD,
+                text_color=Colors.TEXT_ERROR,
+                anchor="w",
+                justify="left",
+                wraplength=580,
+            )
+            msg_label.pack(fill="x", pady=(0, 8) if traceback else (0, 2))
+
+        # ── Traceback code box (shown only when traceback is present) ──
+        if traceback:
+            tb_frame = ctk.CTkFrame(
+                self._content,
+                fg_color="#0D0404",
+                corner_radius=8,
+                border_width=1,
+                border_color=Colors.BORDER_RED,
+            )
+            tb_frame.pack(fill="x")
+
+            tb_label = ctk.CTkLabel(
+                tb_frame,
+                text=traceback,
+                font=FONT_MONO,
+                text_color=Colors.TEXT_ERROR,
+                anchor="nw",
+                justify="left",
+            )
+            tb_label.pack(fill="x", padx=12, pady=10, anchor="w")

chadconsole/ui_engine.py

@@ -0,0 +1,308 @@
+"""
+chadconsole.ui_engine
+~~~~~~~~~~~~~~~~~~~~~
+
+Main CustomTkinter window with queue-driven rendering loop.
+Polls the shared queue every 50ms and instantiates the appropriate
+ui_components widget based on the payload tag.
+"""
+
+from __future__ import annotations
+
+import queue
+import sys
+import traceback
+from pathlib import Path
+
+try:
+    from PIL import Image
+except ImportError:
+    Image = None
+
+import customtkinter as ctk
+
+from chadconsole.data_analyzer import ErrorPayload, InputRequest, Payload
+from chadconsole.ui_components import (
+    Colors,
+    ErrorBlock,
+    FONT_BODY,
+    FONT_HEADER,
+    FONT_LABEL,
+    FONT_TITLE,
+    InputBlock,
+    LoopPatternBlock,
+    StandardBlock,
+    StructuredBlock,
+)
+
+# ---------------------------------------------------------------------------
+# Assets
+# ---------------------------------------------------------------------------
+_ASSETS_DIR = Path(__file__).parent / "assets"
+_LOGO_PATH = _ASSETS_DIR / "logo.png"
+
+
+# ---------------------------------------------------------------------------
+# Tag → Component mapping
+# ---------------------------------------------------------------------------
+
+_TAG_WIDGET_MAP = {
+    "standard":     StandardBlock,
+    "list":         StructuredBlock,
+    "dictionary":   StructuredBlock,
+    "tuple":        StructuredBlock,
+    "loop_pattern": LoopPatternBlock,
+}
+
+# Original stderr for error logging (never intercepted)
+_stderr = sys.__stderr__
+
+
+# ---------------------------------------------------------------------------
+# PrettyConsoleApp — The Main Window
+# ---------------------------------------------------------------------------
+
+class PrettyConsoleApp(ctk.CTk):
+    """Premium dark-mode console window.
+
+    Continuously polls a thread-safe queue and renders payloads as
+    visual blocks in a scrollable canvas.
+    """
+
+    POLL_INTERVAL_MS = 50   # ~20 fps
+    MAX_DRAIN = 10          # Max items per poll tick
+
+    def __init__(self, output_queue: queue.Queue) -> None:
+        super().__init__()
+
+        self._queue = output_queue
+        self._input_handler = None  # Set later via set_input_handler()
+        self._closed = False
+
+        # ── Window configuration ──────────────────────────────────────
+        ctk.set_appearance_mode("dark")
+        ctk.set_default_color_theme("blue")
+
+        self.title("✦ Chad Console")
+        self.geometry("780x500")
+        self.minsize(520, 400)
+        self.configure(fg_color=Colors.BG_MAIN)
+
+        # ── Header bar ────────────────────────────────────────────────
+        header = ctk.CTkFrame(self, fg_color=Colors.BG_CARD_NAVBAR, height=60, corner_radius=0)
+        header.pack(fill="x", side="top")
+        header.pack_propagate(False)
+
+        # App icon + title
+        title_frame = ctk.CTkFrame(header, fg_color="transparent")
+        title_frame.place(relx=0.5, rely=0.5, anchor="center")
+
+        # Try to load premium logo image, fallback to text icon if not found
+        icon_label = None
+        if _LOGO_PATH.exists():
+            try:
+                pil_img = Image.open(_LOGO_PATH)
+                logo_img = ctk.CTkImage(light_image=pil_img, dark_image=pil_img, size=(40, 40))
+                icon_label = ctk.CTkLabel(
+                    title_frame,
+                    image=logo_img,
+                    text="",
+                )
+            except Exception:
+                pass
+
+        if icon_label is None:
+            icon_label = ctk.CTkLabel(
+                title_frame,
+                text="✦",
+                font=("Inter", 22),
+                text_color=Colors.ACCENT_BLUE,
+            )
+        icon_label.pack(side="left", padx=(0, 1))
+
+        text_frame = ctk.CTkFrame(title_frame, fg_color="transparent")
+        text_frame.pack(side="left")
+
+        title_label = ctk.CTkLabel(
+            text_frame,
+            text="Chad Console",
+            font=FONT_TITLE,
+            text_color=Colors.TEXT_PRIMARY,
+        )
+        title_label.pack(anchor="w")
+
+        slogan_label = ctk.CTkLabel(
+            text_frame,
+            text="Charming Python Console",
+            font=("Inter", 11),
+            text_color=Colors.TEXT_DIM,
+        )
+        slogan_label.pack(anchor="w", pady=(0, 0))
+
+        # Subtle version badge
+
+
+        # ── Separator line ────────────────────────────────────────────
+
+
+        # ── Scrollable content area ───────────────────────────────────
+        self._scroll_frame = ctk.CTkScrollableFrame(
+            self,
+            fg_color=Colors.BG_MAIN,
+            corner_radius=0,
+            scrollbar_button_color=Colors.BORDER_SUBTLE,
+            scrollbar_button_hover_color=Colors.TEXT_DIM,
+        )
+        self._scroll_frame.pack(fill="both", expand=True, padx=0, pady=0)
+
+        # ── Status bar ────────────────────────────────────────────────
+        self._status_bar = ctk.CTkFrame(self, fg_color=Colors.BG_CARD, height=30, corner_radius=0)
+        self._status_bar.pack(fill="x", side="bottom")
+        self._status_bar.pack_propagate(False)
+
+        self._status_label = ctk.CTkLabel(
+            self._status_bar,
+            text="● Connected",
+            font=FONT_LABEL,
+            text_color=Colors.ACCENT_GREEN,
+        )
+        self._status_label.pack(side="left", padx=16, pady=4)
+
+        self._block_count = 0
+        self._count_label = ctk.CTkLabel(
+            self._status_bar,
+            text="0 blocks",
+            font=FONT_LABEL,
+            text_color=Colors.TEXT_SECONDARY,
+        )
+        self._count_label.pack(side="right", padx=16, pady=4)
+
+        # ── Lifecycle ─────────────────────────────────────────────────
+        self.protocol("WM_DELETE_WINDOW", self._on_close)
+
+        # Start the rendering loop
+        self.after(self.POLL_INTERVAL_MS, self._poll_queue)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def set_input_handler(self, handler) -> None:
+        """Wire the input handler so InputBlock can resolve responses."""
+        self._input_handler = handler
+
+    # ------------------------------------------------------------------
+    # Queue polling & rendering
+    # ------------------------------------------------------------------
+
+    def _poll_queue(self) -> None:
+        """Drain up to MAX_DRAIN items from the queue and render them."""
+        if self._closed:
+            return
+
+        try:
+            items_processed = 0
+            while items_processed < self.MAX_DRAIN:
+                try:
+                    item = self._queue.get_nowait()
+                except queue.Empty:
+                    break
+
+                self._render_item(item)
+                items_processed += 1
+        except Exception:
+            _stderr.write(f"[ChadConsole] poll error:\n{traceback.format_exc()}\n")
+
+        # Always schedule next poll (even after errors)
+        if not self._closed:
+            self.after(self.POLL_INTERVAL_MS, self._poll_queue)
+
+    def _render_item(self, item) -> None:
+        """Instantiate the correct widget for a queue item."""
+        try:
+            if isinstance(item, InputRequest):
+                self._render_input(item)
+            elif isinstance(item, ErrorPayload):
+                self._render_error(item)
+            elif isinstance(item, Payload):
+                self._render_payload(item)
+        except Exception:
+            _stderr.write(f"[ChadConsole] render error:\n{traceback.format_exc()}\n")
+
+    def _render_payload(self, payload: Payload) -> None:
+        """Render a tagged Payload as the appropriate visual block."""
+        widget_cls = _TAG_WIDGET_MAP.get(payload.tag, StandardBlock)
+
+        if widget_cls is StructuredBlock:
+            widget = widget_cls(
+                self._scroll_frame,
+                text=payload.content,
+                data_type=payload.tag,
+            )
+        else:
+            widget = widget_cls(
+                self._scroll_frame,
+                text=payload.content,
+            )
+
+        widget.pack()
+        self._block_count += 1
+        self._count_label.configure(text=f"{self._block_count} blocks")
+
+        # Auto-scroll to bottom
+        self._scroll_to_bottom()
+
+    def _render_input(self, req: InputRequest) -> None:
+        """Render an InputBlock and wire its submit callback."""
+        handler = req.handler or self._input_handler
+
+        def on_submit(value: str) -> None:
+            if handler:
+                handler.resolve(value)
+            self._block_count += 1
+            self._count_label.configure(text=f"{self._block_count} blocks")
+
+        widget = InputBlock(
+            self._scroll_frame,
+            prompt=req.prompt,
+            on_submit=on_submit,
+        )
+        widget.pack()
+
+        # Auto-scroll to bottom
+        self._scroll_to_bottom()
+
+    def _render_error(self, err: ErrorPayload) -> None:
+        """Render an ErrorBlock for an unhandled exception."""
+        widget = ErrorBlock(
+            self._scroll_frame,
+            error_type=err.error_type,
+            message=err.message,
+            traceback=err.traceback,
+        )
+        widget.pack()
+        self._block_count += 1
+        self._count_label.configure(text=f"{self._block_count} blocks")
+        self._scroll_to_bottom()
+
+    def _scroll_to_bottom(self) -> None:
+        """Schedule a scroll-to-bottom after the widget is rendered."""
+        def _do_scroll():
+            try:
+                self._scroll_frame._parent_canvas.yview_moveto(1.0)
+            except Exception:
+                pass  # Graceful fallback if internal API changes
+        self.after(30, _do_scroll)
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    def _on_close(self) -> None:
+        """Handle window close — restore originals and destroy."""
+        self._closed = True
+        from chadconsole.core_interceptor import uninstall
+        uninstall()
+
+        self._status_label.configure(text="● Disconnected", text_color=Colors.TEXT_DIM)
+        self.after(100, self.destroy)