c4reqber 5.6.0__py3-none-any.whl

src/tui/delta_renderer.py

@@ -0,0 +1,265 @@
+# SPDX-License-Identifier: AGPL-3.0
+# Copyright (c) 2026 c4reqber Contributors
+"""Delta renderer — flicker-free terminal updates by tracking cell diffs.
+
+Instead of clear+redraw (which flickers), we track the previous frame as a
+grid of cells and only write ANSI escape sequences for cells that changed.
+
+Usage:
+    dr = DeltaRenderer(width=80, height=24)
+    for frame in frames:
+        dr.render(frame)  # only changed cells are sent to stdout
+"""
+from __future__ import annotations
+
+import sys
+from typing import Iterator, TextIO
+
+
+ANSI_RESET = "\033[0m"
+
+
+class Cell:
+    """Cell."""
+    __slots__ = ("char", "fg", "bg", "bold", "dim")
+
+    def __init__(
+        self,
+        char: str = " ",
+        fg: str = "",
+        bg: str = "",
+        bold: bool = False,
+        dim: bool = False,
+    ) -> None:
+        self.char = char
+        self.fg = fg
+        self.bg = bg
+        self.bold = bold
+        self.dim = dim
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Cell):
+            return False
+        return (
+            self.char == other.char
+            and self.fg == other.fg
+            and self.bg == other.bg
+            and self.bold == other.bold
+            and self.dim == other.dim
+        )
+
+    def to_ansi(self) -> str:
+        """To ansi."""
+        parts = []
+        if self.bold:
+            parts.append("\033[1m")
+        if self.dim:
+            parts.append("\033[2m")
+        if self.fg:
+            parts.append(self.fg)
+        if self.bg:
+            parts.append(self.bg)
+        parts.append(self.char)
+        return "".join(parts)
+
+
+class DeltaRenderer:
+    """Flicker-free terminal frame rendering.
+
+    Maintains a grid of the previous frame. On each render(),
+    compares new frame against cached grid and writes only
+    changed cells using absolute cursor positioning (ANSI CSI n;mH).
+    """
+
+    def __init__(self, width: int = 80, height: int = 24) -> None:
+        self.width = width
+        self.height = height
+        self._grid: list[list[Cell]] = [
+            [Cell() for _ in range(width)] for _ in range(height)
+        ]
+        self._frame_count = 0
+        self._total_diffs = 0
+        self._initialized = False
+
+    def _ansi_move(self, row: int, col: int) -> str:
+        """Move cursor to 1-based (row, col)."""
+        return f"\033[{row};{col}H"
+
+    def _ansi_color(self, hex_color: str, is_fg: bool = True) -> str:
+        """Convert #rrggbb to ANSI 256-color or truecolor."""
+        if not hex_color or not hex_color.startswith("#"):
+            return ""
+        h = hex_color.lstrip("#")
+        if len(h) != 6:
+            return ""
+        r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+        layer = 16 if is_fg else 48
+        return f"\033[{layer};2;{r};{g};{b}m"
+
+    def _parse_rich_line(self, line: str, row: int) -> list[Cell]:
+        """Parse a Rich-markup string line into Cell grid row.
+
+        Handles basic Rich tags: [color], [/color], [bold], [dim].
+        Does NOT handle nested tags or all edge cases — but enough
+        for the C4REQBER TUI which uses simple markup.
+        """
+        cells = [Cell() for _ in range(self.width)]
+        col = 0
+        i = 0
+
+        current_fg = ""
+        current_bg = ""
+        current_bold = False
+        current_dim = False
+
+        style_stack: list[dict[str, bool | str]] = []
+
+        while i < len(line) and col < self.width:
+            ch = line[i]
+
+            if ch == "[":
+                end = line.find("]", i)
+                if end == -1:
+                    break
+                tag = line[i + 1 : end]
+
+                if tag.startswith("/"):
+                    clean = tag[1:]
+                    if clean.startswith("#"):
+                        if style_stack:
+                            prev = style_stack.pop()
+                            current_fg = str(prev.get("fg", ""))
+                            current_bold = bool(prev.get("bold", False))
+                            current_dim = bool(prev.get("dim", False))
+                    elif clean == "bold":
+                        if style_stack:
+                            prev = style_stack.pop()
+                            current_bold = bool(prev.get("bold", False))
+                    elif clean == "dim":
+                        if style_stack.pop():
+                            current_dim = bool(style_stack[-1].get("dim", False)) if style_stack else False
+                else:
+                    style_stack.append({
+                        "fg": current_fg,
+                        "bg": current_bg,
+                        "bold": current_bold,
+                        "dim": current_dim,
+                    })
+                    if tag.startswith("#") or tag.startswith("rgb"):
+                        current_fg = self._ansi_color(tag)
+                    elif tag == "bold":
+                        current_bold = True
+                    elif tag == "dim":
+                        current_dim = True
+
+                i = end + 1
+                continue
+
+            cells[col] = Cell(
+                char=ch,
+                fg=current_fg,
+                bg=current_bg,
+                bold=current_bold,
+                dim=current_dim,
+            )
+            col += 1
+            i += 1
+
+        return cells
+
+    def render(self, frame: str, out: TextIO | None = None) -> None:
+        """Render a frame to stdout, only updating changed cells.
+
+        Args:
+            frame: Multi-line string (plain ANSI or Rich-markup).
+                   Each line becomes one row.
+            out: File-like object (default: sys.stdout).
+        """
+        if out is None:
+            out = sys.stdout
+
+        lines = frame.split("\n")
+        row_count = min(len(lines), self.height)
+
+        if not self._initialized:
+            out.write("\033[2J\033[H")
+            out.write(ANSI_RESET)
+            self._initialized = True
+
+        out.write("\033[?25l")  # hide cursor
+
+        diffs = 0
+
+        for row in range(row_count):
+            line = lines[row]
+            new_cells = self._parse_rich_line(line, row)
+            modified = False
+            run_start = -1
+            run_text: list[str] = []
+
+            for col in range(self.width):
+                old = self._grid[row][col]
+                new = new_cells[col]
+                if old != new:
+                    diffs += 1
+                    if not modified:
+                        modified = True
+                        run_start = col
+                        run_text = []
+                    run_text.append(new.to_ansi())
+                    self._grid[row][col] = new
+                elif modified:
+                    self._flush_run(out, row + 1, run_start + 1, run_text)
+                    modified = False
+
+            if modified:
+                self._flush_run(out, row + 1, run_start + 1, run_text)
+
+        out.write("\033[?25h")  # show cursor
+        out.flush()
+
+        self._frame_count += 1
+        self._total_diffs += diffs
+
+    def _flush_run(
+        self, out: TextIO, row: int, col: int, text: list[str]
+    ) -> None:
+        """Write a contiguous run of changed cells at (row, col)."""
+        out.write(self._ansi_move(row, col))
+        out.write("".join(text))
+        out.write(ANSI_RESET)
+
+    def stats(self) -> dict[str, object]:
+        return {
+            "frames": self._frame_count,
+            "total_diffs": self._total_diffs,
+            "avg_diffs_per_frame": (
+                self._total_diffs / max(1, self._frame_count)
+            ),
+        }
+
+
+def split_into_cells(text: str, width: int = 80) -> list[list[str]]:
+    """Split multi-line text into per-line character lists, padded to width."""
+    lines = text.split("\n")
+    result: list[list[str]] = []
+    for line in lines:
+        chars = list(line)
+        chars.extend([" "] * max(0, width - len(chars)))
+        result.append(chars[:width])
+    while len(result) < 24:
+        result.append([" "] * width)
+    return result
+
+
+def diff_and_patch(
+    old_lines: list[str],
+    new_lines: list[str],
+) -> Iterator[tuple[int, int, str]]:
+    """Yield (row, col, ansi_text) for changed cells between two frames."""
+    for row, (old, new) in enumerate(zip(old_lines, new_lines, strict=False)):
+        for col in range(max(len(old), len(new))):
+            oc = old[col] if col < len(old) else " "
+            nc = new[col] if col < len(new) else " "
+            if oc != nc:
+                yield (row + 1, col + 1, nc)

src/tui/depth_ladder.py

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: AGPL-3.0
+# Copyright (c) 2026 c4reqber Contributors
+from __future__ import annotations
+
+from typing import Any
+
+from rich.console import Group
+from rich.panel import Panel
+from rich.progress_bar import ProgressBar
+from rich.text import Text
+from textual.widgets import Static
+
+
+class DepthLadder(Static):
+    """Three-rung ladder: C1 Discovery → C2 Formalization → C3 Verification."""
+
+    LAYERS = [
+        (1, "Discovery", "cyan"),
+        (2, "Formalization", "yellow"),
+        (3, "Verification", "magenta"),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__("")
+        self._progress: dict[int, float] = {1: 0.0, 2: 0.0, 3: 0.0}
+
+    def update_layer(self, layer: int, percent: float) -> None:
+        self._progress[layer] = min(1.0, max(0.0, percent))
+
+    def set_from_pipeline_step(self, step: int, total: int = 12) -> None:
+        """Set from pipeline step."""
+        ratio = step / total
+        self._progress[1] = min(1.0, ratio / 0.33)  # Steps 1-4
+        self._progress[2] = min(1.0, max(0.0, (ratio - 0.33) / 0.33))  # Steps 5-8
+        self._progress[3] = min(1.0, max(0.0, (ratio - 0.66) / 0.34))  # Steps 9-12
+
+    def render(self) -> Panel:
+        """Render."""
+        lines: list[Any] = []
+        for layer, name, color in self.LAYERS:
+            pct = self._progress[layer]
+            bar = ProgressBar(total=100, completed=int(pct * 100), width=20)
+            label = Text()
+            label.append(f"C{layer} {name:<16}", style=color)
+            label.append(f" {int(pct * 100):>3}%", style="bold")
+            if pct >= 1.0:
+                label.append(" ✓", style="bold green")
+            lines.append(label)
+            lines.append(bar)
+        return Panel(Group(*lines), title="Depth Ladder", border_style="cyan")

src/tui/diagnostics.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+
+"""
+TUI: Diagnostics
+Diagnostic wizard and related methods for C4TUI.
+"""
+
+
+from rich import box
+from rich.panel import Panel
+from rich.text import Text
+
+
+def make_diagnostic_wizard(t, router, q1: str = '', q2: str = '', q3: str = '') -> Panel:
+    """Render the 30-second diagnostic wizard panel."""
+    _DIAG_Q1_MAP = {'1': 'Регулятивный', '2': 'Структурний', '3': 'Смисловий', '4': 'Реляціонний'}
+    _DIAG_Q2_MAP = {'1': 'Градієнтний', '2': 'Дискретний', '3': 'Циклічний', '4': 'Каскадний'}
+    _DIAG_Q3_MAP = {'1': 'Упругий', '2': 'Умовно-упругий', '3': 'Необоротний'}
+    _DIAG_SITUATION_MAP = {'Регулятивний': 'overload', 'Структурний': 'rigidity', 'Смисловий': 'chaos', 'Реляціонний': 'isolation'}
+
+    def _marker(selected: str, key: str, label: str) -> str:
+        if selected == key:
+            return f"[bold #4ECDC4]▶ [{key}] {label}[/]"
+        return f"  [{key}] {label}"
+
+    q1_text = (
+        f"  [bold]1. ЩО трансформується?[/]\n"
+        f"     {_marker(q1, '1', 'Стан')}\n"
+        f"     {_marker(q1, '2', 'Структура')}\n"
+        f"     {_marker(q1, '3', 'Смисл')}\n"
+        f"     {_marker(q1, '4', 'Відношення')}"
+    )
+
+    q2_text = (
+        f"  [bold]2. ЯК проходить зміна?[/]\n"
+        f"     {_marker(q2, '1', 'Поступово')}\n"
+        f"     {_marker(q2, '2', 'Стрибком')}\n"
+        f"     {_marker(q2, '3', 'Циклічно')}\n"
+        f"     {_marker(q2, '4', 'Каскадно')}"
+    )
+
+    q3_text = (
+        f"  [bold]3. ОБРАТИМО чи зміна?[/]\n"
+        f"     {_marker(q3, '1', 'Да')}\n"
+        f"     {_marker(q3, '2', 'Умовно')}\n"
+        f"     {_marker(q3, '3', 'Ні')}"
+    )
+
+    code = ''
+    if q1 and q2 and q3:
+        p1 = _DIAG_Q1_MAP.get(q1, 'Регулятивний')
+        p2 = _DIAG_Q2_MAP.get(q2, 'Градієнтний')
+        p3 = _DIAG_Q3_MAP.get(q3, 'Упругий')
+        code = f"{p1}-{p2}-{p3}"
+
+        situation = _DIAG_SITUATION_MAP.get(p1, 'chaos')
+        gap_pct = 25 if p3 == 'Упругий' else (50 if p3 == 'Умовно-упругий' else 85)
+        ops = router.route(situation, gap_pct)
+
+        level = 'SIMPLE' if gap_pct < 30 else ('MEDIUM' if gap_pct <= 70 else 'COMPLEX')
+        info = (
+            f"\n\n  [bold #4ECDC4]Ваш код:[/] [{code}]\n"
+            f"  [bold #4ECDC4]Рекомендовані оператори:[/] {' → '.join(ops)}\n"
+            f"  [bold #4ECDC4]Рівень складності:[/] {level} (GAP < {'30' if gap_pct < 30 else '70' if gap_pct <= 70 else '100'}%)"
+        )
+    else:
+        info = "\n\n  [dim]Виберіть відповіді на все 3 питання[/]"
+
+    body = Text.from_markup(
+        f"{q1_text}\n\n{q2_text}\n\n{q3_text}{info}"
+    )
+
+    return Panel(
+        body,
+        title="[bold]🧠 ДІАГНОСТЮКА ПРОБЛЕМА (30 секунд)[/]",
+        border_style="bold #FFD93D",
+        box=box.ROUNDED,
+        padding=(1, 4),
+    )
+
+
+def run_diagnostic_wizard(keyboard_reader, make_diagnostic_wizard_fn, router) -> dict:
+    """Interactive diagnostic wizard returning problem profile."""
+    _DIAG_Q1_MAP = {'1': 'Регулятивний', '2': 'Структурний', '3': 'Смисловий', '4': 'Реляціонний'}
+    _DIAG_Q2_MAP = {'1': 'Градієнтний', '2': 'Дискретний', '3': 'Циклічний', '4': 'Каскадний'}
+    _DIAG_Q3_MAP = {'1': 'Упругий', '2': 'Умовно-упругий', '3': 'Необоротний'}
+    _DIAG_SITUATION_MAP = {'Регулятивний': 'overload', 'Структурний': 'rigidity', 'Смисловий': 'chaos', 'Реляціонний': 'isolation'}
+
+    selections: dict = {'q1': '1', 'q2': '1', 'q3': '1'}
+    current_q = 'q1'
+
+    with keyboard_reader as kr:
+        while True:
+            import sys
+            sys.stdout.write("\033[2J\033[H")
+            sys.stdout.flush()
+            print(make_diagnostic_wizard_fn(selections['q1'], selections['q2'], selections['q3']))
+            sys.stdout.flush()
+
+            key = kr.read_key(timeout=0.3)
+
+            if key is None:
+                continue
+
+            if key == ('esc',) or key == ('char', 'q') or key == ('char', 'Q'):
+                return {}
+
+            if key == ('char', '1'):
+                selections[current_q] = '1'
+                if current_q == 'q1':
+                    current_q = 'q2'
+                elif current_q == 'q2':
+                    current_q = 'q3'
+                else:
+                    continue
+
+            elif key == ('char', '2'):
+                selections[current_q] = '2'
+                if current_q == 'q1':
+                    current_q = 'q2'
+                elif current_q == 'q2':
+                    current_q = 'q3'
+                else:
+                    continue
+
+            elif key == ('char', '3'):
+                selections[current_q] = '3'
+                if current_q == 'q1':
+                    current_q = 'q2'
+                elif current_q == 'q2':
+                    current_q = 'q3'
+                else:
+                    continue
+
+            elif key == ('char', '4'):
+                if current_q in ('q1', 'q2'):
+                    selections[current_q] = '4'
+                    if current_q == 'q1':
+                        current_q = 'q2'
+                    elif current_q == 'q2':
+                        current_q = 'q3'
+                else:
+                    continue
+
+            elif key == ('enter',):
+                if selections['q1'] and selections['q2'] and selections['q3']:
+                    break
+
+    p1 = _DIAG_Q1_MAP.get(selections['q1'], 'Регулятивний')
+    p2 = _DIAG_Q2_MAP.get(selections['q2'], 'Градієнтний')
+    p3 = _DIAG_Q3_MAP.get(selections['q3'], 'Упругий')
+    code = f"{p1}-{p2}-{p3}"
+
+    situation = _DIAG_SITUATION_MAP.get(p1, 'chaos')
+    gap_pct = 25 if p3 == 'Упругий' else (50 if p3 == 'Умовно-упругий' else 85)
+    ops = router.route(situation, gap_pct)
+
+    fp = router.fingerprint("diagnostic problem")
+    fp.update({
+        'code': code,
+        'gap_pct': gap_pct,
+        'operator_chain': ops,
+    })
+    return fp

src/tui/easing.py

@@ -0,0 +1,104 @@
+# SPDX-License-Identifier: AGPL-3.0
+# Copyright (c) 2026 c4reqber Contributors
+"""Physics easing curves for smooth animations — cubic, elastic, inertia.
+
+Usage:
+    pos = ease_out_cubic(t)          # t in [0.0, 1.0] → eased position
+    step = inertia_step(velocity, dt, friction=0.92)  # physics simulation
+"""
+from __future__ import annotations
+
+import math
+import time
+from typing import Callable
+
+
+EasingFn = Callable[[float], float]
+
+
+def ease_out_cubic(t: float) -> float:
+    """Cubic ease-out — fast start, gradual deceleration. Like a rolling ball."""
+    return 1.0 - (1.0 - t) ** 3
+
+
+def ease_in_out_cubic(t: float) -> float:
+    """Cubic ease-in-out — smooth acceleration then deceleration. Flywheel feel."""
+    if t < 0.5:
+        return 4.0 * t * t * t
+    return 1.0 - pow(-2.0 * t + 2.0, 3) / 2.0
+
+
+def ease_out_elastic(t: float) -> float:
+    """Elastic ease-out — overshoots then settles. Like a spring doorstop."""
+    if t == 0.0 or t == 1.0:
+        return t
+    c4 = (2.0 * math.pi) / 3.0
+    return pow(2.0, -10.0 * t) * math.sin((t * 10.0 - 0.75) * c4) + 1.0
+
+
+def ease_out_back(t: float) -> float:
+    """Back ease-out — overshoots slightly, then returns. Premium UI feel."""
+    c1 = 1.70158
+    c3 = c1 + 1.0
+    return 1.0 + c3 * pow(t - 1.0, 3) + c1 * pow(t - 1.0, 2)
+
+
+def ease_out_quart(t: float) -> float:
+    """Quartic ease-out — faster than cubic, heavier deceleration."""
+    return 1.0 - pow(1.0 - t, 4)
+
+
+def ease_out_expo(t: float) -> float:
+    """Exponential ease-out — very fast start, long tail. Particle-like."""
+    if t == 1.0:
+        return 1.0
+    return 1.0 - pow(2.0, -10.0 * t)
+
+
+EASING_MAP: dict[str, EasingFn] = {
+    "cubic": ease_out_cubic,
+    "in_out_cubic": ease_in_out_cubic,
+    "elastic": ease_out_elastic,
+    "back": ease_out_back,
+    "quart": ease_out_quart,
+    "expo": ease_out_expo,
+}
+
+
+class InertiaSimulation:
+    """Simulates physical inertia for UI elements (cube, cursors, scroll).
+
+    Like a car coasting — velocity decays with friction.
+    Position is the integral of velocity over time.
+    """
+
+    def __init__(self, friction: float = 0.92, mass: float = 1.0) -> None:
+        self.friction = friction
+        self.mass = mass
+        self.velocity = 0.0
+        self.position = 0.0
+        self._last_tick: float | None = None
+
+    def tick(self, dt: float) -> float:
+        """Advance physics by dt seconds. Returns new position."""
+        self.velocity *= self.friction
+        self.position += self.velocity * dt
+        return self.position
+
+    def push(self, force: float) -> None:
+        """Apply instantaneous impulse."""
+        self.velocity += force / self.mass
+
+    def auto_tick(self) -> float:
+        """Tick using real elapsed time since last call."""
+        now = time.monotonic()
+        if self._last_tick is None:
+            self._last_tick = now
+            return self.position
+        dt = now - self._last_tick
+        self._last_tick = now
+        return self.tick(dt)
+
+    def is_still(self, threshold: float = 0.001) -> bool:
+        """True when velocity is negligible."""
+        return abs(self.velocity) < threshold

src/tui/entry.py

@@ -0,0 +1,79 @@
+"""TUI: Entry Point — delegates to v8 Go binary."""
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+
+def _find_binary() -> Path | None:
+    """Locate the c4tui-v8 binary."""
+    root = Path(__file__).resolve().parents[2]
+    candidates = [
+        root / "bin" / "c4tui-v8",
+        root / "src" / "tui" / "v8" / "c4tui-v8",
+        root / "src" / "tui" / "v8" / "c4tui",
+    ]
+    for c in candidates:
+        if c.exists():
+            return c
+    return None
+
+
+def main() -> None:
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="c44tcdi — Cognitive Exoskeleton TUI v8")
+    sub = parser.add_subparsers(dest="command")
+
+    tui_cmd = sub.add_parser("tui", help="Interactive TUI (Go-based v8)")
+    tui_cmd.add_argument("--lang", "-l", choices=["en", "ru", "zh", "ja", "de", "ar", "hi"], default=None, help="UI language")
+    tui_cmd.add_argument("--theme", "-t", choices=["dark", "matrix", "paper"], default=None, help="Color theme")
+    tui_cmd.add_argument("--api", default=None, help="Override API base URL")
+
+    solve = sub.add_parser("solve", help="One-shot discovery (use CLI blast)")
+    solve.add_argument("problem", help="Problem description")
+    solve.add_argument("--domain", "-d", default="science")
+
+    sub.add_parser("quickstart", help="Interactive 3-step onboarding (TUI)")
+    sub.add_parser("cube", help="Show ASCII cube (TUI)")
+
+    args = parser.parse_args()
+
+    if args.command == "tui":
+        binary = _find_binary()
+        if binary is None:
+            print("c4tui-v8 binary not found. Build it first:")
+            print("  cd src/tui/v8 && go build -o c4tui-v8 .")
+            sys.exit(1)
+        cmd = [str(binary)]
+        if args.lang:
+            cmd += ["--lang", args.lang]
+        if args.theme:
+            cmd += ["--theme", args.theme]
+        if args.api:
+            cmd += ["--api", args.api]
+        subprocess.run(cmd)
+    elif args.command == "solve":
+        print("Use: blast solve 'your problem' --domain science")
+        sys.exit(1)
+    elif args.command == "quickstart":
+        binary = _find_binary()
+        if binary:
+            subprocess.run([str(binary)])
+        else:
+            print("c4tui-v8 binary not found.")
+            sys.exit(1)
+    elif args.command == "cube":
+        binary = _find_binary()
+        if binary:
+            subprocess.run([str(binary)])
+        else:
+            print("c4tui-v8 binary not found.")
+            sys.exit(1)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()