@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/tui/widgets/agent_thought.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from typing import ClassVar
+
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Vertical
+from textual.reactive import reactive
+from textual.widgets import Markdown, Static
+from textual.widgets.markdown import MarkdownStream
+
+
+
+class AgentThought(Vertical, can_focus=True):
+    """The agent's 'thoughts' with collapsible header.
+
+    During streaming: header shows "⏳ thinking:", content visible (expanded).
+    After completion: header shows "+ Thought" (collapsed).
+    Ctrl+X or click on header toggles expand/collapse.
+
+    Content is rendered as Markdown (bold, italic, code, lists, etc.).
+    """
+
+    HELP = """
+## Agent thoughts
+
+- **ctrl+x** Toggle expand/collapse
+- **click on header** Toggle expand/collapse
+- **cursor keys** Scroll text
+"""
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("ctrl+x", "toggle", "Toggle", show=False, priority=True),
+        Binding("up", "scroll_up", "Scroll Up", show=False),
+        Binding("down", "scroll_down", "Scroll Down", show=False),
+        Binding("left", "scroll_left", "Scroll Left", show=False),
+        Binding("right", "scroll_right", "Scroll Right", show=False),
+        Binding("home", "scroll_home", "Scroll Home", show=False),
+        Binding("end", "scroll_end", "Scroll End", show=False),
+        Binding("pageup", "page_up", "Page Up", show=False),
+        Binding("pagedown", "page_down", "Page Down", show=False),
+        Binding("ctrl+pageup", "page_left", "Page Left", show=False),
+        Binding("ctrl+pagedown", "page_right", "Page Right", show=False),
+    ]
+
+    ALLOW_MAXIMIZE = True
+
+    DEFAULT_CSS = """
+    AgentThought {
+        height: auto;
+        width: 1fr;
+    }
+    """
+
+    loading: reactive[bool] = reactive(False)
+
+    def watch_loading(self, loading: bool) -> None:
+        self.set_class(loading, "-loading")
+
+    def __init__(self, initial_content: str = "", *, replay: bool = False):
+        super().__init__()
+        self._initial_content = initial_content
+        self._stream: MarkdownStream | None = None
+        self._completed = False
+        self._collapsed = False
+        self._replay = replay
+
+    def compose(self) -> ComposeResult:
+        yield Static("⏳ thinking:", id="thought-header")
+        yield Markdown(self._initial_content, id="thought-content")
+
+    def on_mount(self) -> None:
+        # Force proper sizing — Vertical defaults to height: 1fr which
+        # collapses to 0 inside a VerticalScroll parent.
+        self.styles.height = "auto"
+        self.styles.min_height = 3
+        self._completed = self._replay
+        self._collapsed = self._replay
+        self._update_header()
+        content = self.query_one("#thought-content", Markdown)
+        content.display = not self._collapsed
+        content.styles.height = "auto"
+
+    async def append_fragment(self, fragment: str) -> None:
+        content = self.query_one("#thought-content", Markdown)
+        if self._stream is None:
+            self._stream = Markdown.get_stream(content)
+        await self._stream.write(fragment)
+        content.scroll_end()
+
+    def mark_completed(self) -> None:
+        if self._completed:
+            return
+        self._completed = True
+        self._collapsed = True
+        self._update_header()
+        self.query_one("#thought-content", Markdown).display = False
+
+    def action_toggle(self) -> None:
+        self._collapsed = not self._collapsed
+        self._update_header()
+        self.query_one("#thought-content", Markdown).display = not self._collapsed
+
+    def on_click(self, event) -> None:
+        """Toggle when the header is clicked (only after completion)."""
+        if not self._completed:
+            return
+        if getattr(event.widget, "id", None) == "thought-header":
+            self.action_toggle()
+            event.stop()
+
+    def _update_header(self) -> None:
+        header = self.query_one("#thought-header", Static)
+        if not self._completed:
+            header.update("⏳ thinking:")
+        elif self._collapsed:
+            header.update("+ Thought")
+        else:
+            header.update("- Thought")
+
+    # ── ExpandProtocol ──
+
+    def can_expand(self) -> bool:
+        return True
+
+    def expand_block(self) -> None:
+        if self._collapsed:
+            self.action_toggle()
+
+    def collapse_block(self) -> None:
+        if not self._collapsed:
+            self.action_toggle()
+
+    def is_block_expanded(self) -> bool:
+        return not self._collapsed
+
+    # ── Forward scroll actions to inner Markdown ──
+
+    def action_scroll_up(self) -> None:
+        self.query_one(Markdown).scroll_up()
+
+    def action_scroll_down(self) -> None:
+        self.query_one(Markdown).scroll_down()
+
+    def action_scroll_left(self) -> None:
+        self.query_one(Markdown).scroll_left()
+
+    def action_scroll_right(self) -> None:
+        self.query_one(Markdown).scroll_right()
+
+    def action_scroll_home(self) -> None:
+        self.query_one(Markdown).scroll_home()
+
+    def action_scroll_end(self) -> None:
+        self.query_one(Markdown).scroll_end()
+
+    def action_page_up(self) -> None:
+        self.query_one(Markdown).scroll_page_up()
+
+    def action_page_down(self) -> None:
+        self.query_one(Markdown).scroll_page_down()
+
+    def action_page_left(self) -> None:
+        self.query_one(Markdown).scroll_page_left()
+
+    def action_page_right(self) -> None:
+        self.query_one(Markdown).scroll_page_right()

package/tui/widgets/aidlc.py

@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import yaml
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.events import Click
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widgets import Static
+
+
+class AIDLCModeChanged(Message):
+    def __init__(self, mode: str) -> None:
+        super().__init__()
+        self.mode = mode
+
+
+_PHASE_LABELS: dict[str, str] = {
+    "init": "Initialized",
+    "understand": "\u2460 Understand",
+    "plan": "\u2461 Plan",
+    "verify": "\u2462 Verify",
+    "deliver": "\u2463 Deliver",
+}
+
+_PHASE_ORDER: list[str] = ["understand", "plan", "verify", "deliver"]
+
+_AIDLC_MODE_OPTIONS = [
+    ("L0", "closed"),
+    ("L1", "nudge"),
+    ("L2", "auto"),
+    ("L3", "enforce"),
+]
+
+_DEFAULT_AIDLC_MODE = "L2"
+
+
+class AIDLCStats(Static):
+    DEFAULT_CSS = """
+    AIDLCStats {
+        height: auto;
+        padding: 0 1;
+
+        #aidlc-mode-header {
+            margin: 0;
+            padding: 0;
+        }
+
+        #aidlc-mode-options {
+            height: auto;
+        }
+
+        .mode-option {
+            height: auto;
+            padding: 0 1;
+        }
+
+        .mode-option:hover {
+            background: $surface-lighten-1;
+        }
+
+        .mode-indicator {
+            width: auto;
+            margin-right: 1;
+        }
+
+        .mode-option.active .mode-indicator {
+            color: $primary;
+        }
+
+        .mode-label {
+            width: auto;
+        }
+
+        .mode-option.active .mode-label {
+            color: $primary;
+            text-style: bold;
+        }
+
+        #aidlc-phase {
+            text-style: bold;
+            margin: 0;
+            padding: 1 0 0 0;
+        }
+
+        #aidlc-progress {
+            color: $text-secondary;
+            margin: 0;
+            padding: 1 0 0 0;
+        }
+
+        #aidlc-completed {
+            color: $success;
+            margin: 0;
+            padding: 0;
+        }
+
+        #aidlc-gates {
+            color: $text-secondary;
+            margin: 0;
+            padding: 0;
+        }
+    }
+    """
+
+    aidlc_mode: reactive[str] = reactive(_DEFAULT_AIDLC_MODE)
+    current_phase: reactive[str] = reactive("")
+    completed_phases: reactive[list[str]] = reactive(list)
+    gate_results: reactive[dict] = reactive(dict)
+    project_path: reactive[Path | None] = reactive(None)
+
+    def __init__(
+        self,
+        aidlc_mode: str = _DEFAULT_AIDLC_MODE,
+        current_phase: str = "",
+        completed_phases: list[str] | None = None,
+        gate_results: dict | None = None,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        project_path: Path | None = None,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes)
+        self._initial_mode = aidlc_mode
+        self._initial_phase = current_phase
+        self._initial_completed = completed_phases or []
+        self._initial_gates = gate_results or {}
+        self.project_path = project_path
+        self._state_mtime: float | None = None
+        self._project_yaml_mtime: float | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Static("mode level:", id="aidlc-mode-header")
+        with Vertical(id="aidlc-mode-options"):
+            for mode, desc in _AIDLC_MODE_OPTIONS:
+                option = Static(
+                    f"\u25cb {mode}: {desc}",
+                    id=f"mode-option-{mode}",
+                    classes="mode-option",
+                )
+                option.can_focus = True
+                yield option
+        yield Static("", id="aidlc-phase")
+        yield Static("", id="aidlc-progress")
+        yield Static("", id="aidlc-completed")
+        yield Static("", id="aidlc-gates")
+
+    def on_mount(self) -> None:
+        self.aidlc_mode = self._initial_mode
+        self.current_phase = self._initial_phase
+        self.completed_phases = self._initial_completed
+        self.gate_results = self._initial_gates
+        self._load_mode_from_project()
+        self._refresh_display()
+        self._check_state_file()
+        self.set_timer(2.0, self._poll_state_file)
+
+    def _poll_state_file(self) -> None:
+        self._check_state_file()
+        self._check_project_yaml()
+        self.set_timer(2.0, self._poll_state_file)
+
+    def _check_project_yaml(self) -> None:
+        if self.project_path is None:
+            return
+        project_yaml = self.project_path / "aidlc" / "project.yaml"
+        if not project_yaml.exists():
+            return
+        try:
+            mtime = project_yaml.stat().st_mtime
+            if self._project_yaml_mtime is not None and mtime != self._project_yaml_mtime:
+                self._load_mode_from_project()
+            self._project_yaml_mtime = mtime
+        except Exception:
+            pass
+
+    def _load_mode_from_project(self) -> None:
+        if self.project_path is None:
+            return
+        project_yaml = self.project_path / "aidlc" / "project.yaml"
+        if not project_yaml.exists():
+            return
+        try:
+            data = yaml.safe_load(project_yaml.read_text(encoding="utf-8")) or {}
+            settings = data.get("settings", {})
+            mode = settings.get("aidlc_mode", _DEFAULT_AIDLC_MODE)
+            if mode in [m for m, _ in _AIDLC_MODE_OPTIONS]:
+                self.aidlc_mode = mode
+                self._update_indicators(mode)
+        except Exception:
+            pass
+
+    def _save_mode_to_project(self, mode: str) -> None:
+        if self.project_path is None:
+            return
+        project_yaml = self.project_path / "aidlc" / "project.yaml"
+        if not project_yaml.exists():
+            return
+        try:
+            data = yaml.safe_load(project_yaml.read_text(encoding="utf-8")) or {}
+            if "settings" not in data:
+                data["settings"] = {}
+            data["settings"]["aidlc_mode"] = mode
+            project_yaml.write_text(yaml.dump(data, allow_unicode=True), encoding="utf-8")
+        except Exception:
+            pass
+
+    def _check_state_file(self) -> None:
+        if self.project_path is None:
+            return
+        cdh_dir = self.project_path / ".cdh"
+        state_file = cdh_dir / "state.json"
+        if not state_file.exists():
+            return
+        try:
+            mtime = state_file.stat().st_mtime
+            if self._state_mtime is not None and mtime != self._state_mtime:
+                self._load_state_from_file()
+            self._state_mtime = mtime
+        except Exception:
+            pass
+
+    def _load_state_from_file(self) -> None:
+        if self.project_path is None:
+            return
+        cdh_dir = self.project_path / ".cdh"
+        state_file = cdh_dir / "state.json"
+        if not state_file.exists():
+            return
+        try:
+            state = json.loads(state_file.read_text(encoding="utf-8"))
+            self.refresh_from_state(state)
+        except Exception:
+            pass
+
+    def watch_project_path(self, path: Path | None) -> None:
+        self._state_mtime = None
+        self._project_yaml_mtime = None
+        self._check_state_file()
+        self._check_project_yaml()
+
+    def watch_aidlc_mode(self, mode: str) -> None:
+        if self._is_ready():
+            self._update_indicators(mode)
+            self._refresh_display()
+
+    def watch_current_phase(self, phase: str) -> None:
+        if self._is_ready():
+            self._refresh_display()
+
+    def watch_completed_phases(self, completed: list[str]) -> None:
+        if self._is_ready():
+            self._refresh_display()
+
+    def watch_gate_results(self, gates: dict) -> None:
+        if self._is_ready():
+            self._refresh_display()
+
+    def refresh_from_state(self, state: dict) -> None:
+        self.current_phase = state.get("current_phase", "")
+        self.completed_phases = state.get("completed_phases", [])
+        self.gate_results = state.get("gate_results", {})
+
+    def _is_ready(self) -> bool:
+        if not self.is_mounted:
+            return False
+        try:
+            self.query_one("#aidlc-mode-options")
+            return True
+        except Exception:
+            return False
+
+    def _update_indicators(self, active_mode: str) -> None:
+        for mode, desc in _AIDLC_MODE_OPTIONS:
+            option = self.query_one(f"#mode-option-{mode}", Static)
+            if mode == active_mode:
+                option.update(f"\u25cf {mode}: {desc}")
+                option.classes = "mode-option active"
+            else:
+                option.update(f"\u25cb {mode}: {desc}")
+                option.classes = "mode-option"
+
+    def _on_click(self, event) -> None:
+        event.stop()
+        widget_id = event.widget.id
+        if widget_id and widget_id.startswith("mode-option-"):
+            mode = widget_id.replace("mode-option-", "")
+            if mode in [m for m, _ in _AIDLC_MODE_OPTIONS] and mode != self.aidlc_mode:
+                self.aidlc_mode = mode
+                self._save_mode_to_project(mode)
+                self._update_indicators(mode)
+                self.post_message(AIDLCModeChanged(mode))
+
+    def _refresh_display(self) -> None:
+        phase = self.current_phase
+        completed = self.completed_phases
+        gates = self.gate_results
+
+        label = _PHASE_LABELS.get(phase, phase or "\u2014")
+        phase_label = self.query_one("#aidlc-phase", Static)
+        phase_label.update(f"Phase: {label}")
+
+        progress = self.query_one("#aidlc-progress", Static)
+        if completed or phase:
+            done = len(completed) + (1 if phase and phase in _PHASE_ORDER and phase not in completed else 0)
+            progress.update(f"Progress: {done} phase{'s' if done > 1 else ''}")
+        else:
+            progress.update("")
+        completed_label = self.query_one("#aidlc-completed", Static)
+        if completed:
+            names = [_PHASE_LABELS.get(p, p) for p in completed if p != "init"]
+            completed_label.update("Completed: " + ", ".join(names))
+        else:
+            completed_label.update("")
+
+        gates_label = self.query_one("#aidlc-gates", Static)
+        if gates:
+            passed = sum(1 for r in gates.values() if isinstance(r, dict) and r.get("status") == "passed")
+            failed = sum(1 for r in gates.values() if isinstance(r, dict) and r.get("status") == "failed")
+            total_gates = len(gates)
+            parts = []
+            if passed:
+                parts.append(f"\u2713 {passed}")
+            if failed:
+                parts.append(f"\u2717 {failed}")
+            if total_gates - passed - failed:
+                parts.append(f"\u2219 {total_gates - passed - failed}")
+            gates_label.update("Gates: " + " ".join(parts) if parts else f"Gates: {total_gates} total")
+        else:
+            gates_label.update("")