gini-toolkit 6.0.1.dev0__py3-none-any.whl

gini/ui/mode_indicator.py

@@ -0,0 +1,227 @@
+"""Four toolbar pills for GINI: the current MODE, the AI MODEL, the ACTIVITY, and YOU.
+
+  * Mode pill     — which interaction mode is active (Chat / Explain / Wizard / Coach),
+                    coloured per mode.
+  * Model pill    — the connected local model's name + status (green = reachable, amber =
+                    set but not responding, grey = none). Click it to open Settings → LLM.
+  * Activity pill — a rotating spinner while the assistant is thinking, else a steady Idle.
+  * User pill     — your Teaching Center enrolment: who you're signed in as, whether the course
+                    server is reachable, and **how many assigned missions are still due** (0 is a
+                    perfectly good answer, and worth showing — "nothing due" is information).
+                    gBuilder is fully usable signed OUT, so the signed-out state is calm and grey,
+                    not an error. Click it to sign in (Settings) or to jump to your assigned work.
+
+One widget paints them all so the toolbar stays tidy; the Model and User pills are click targets.
+"""
+from __future__ import annotations
+
+from PySide6.QtCore import QRectF, QSize, Qt, QTimer, Signal
+from PySide6.QtGui import QColor, QFont, QFontMetrics, QPainter, QPen
+from PySide6.QtWidgets import QWidget
+
+_GAP = 8
+
+
+class ModeIndicator(QWidget):
+    model_clicked = Signal()          # the Model pill was clicked (open Settings → LLM)
+    user_clicked = Signal()           # the User pill was clicked (sign in, or go to my missions)
+
+    def __init__(self, theme, parent=None) -> None:
+        super().__init__(parent)
+        self.theme = theme
+        self._mode = "Chat"
+        self._busy = False
+        self._angle = 0
+        self._model_name = ""         # "" = no model connected
+        self._model_ok = False        # reachable?
+        self._student = ""            # "" = not enrolled in any course
+        self._tc_ok = False           # course server reachable?
+        self._is_teacher = False      # signed in with a teacher role?
+        self._due = 0                 # assigned missions not yet completed
+        self.setFixedHeight(26)
+        self.setMouseTracking(True)
+        self._timer = QTimer(self)
+        self._timer.setInterval(55)
+        self._timer.timeout.connect(self._spin)
+
+    # -- state from the assistant / main window ----------------------------- #
+    def set_status(self, label: str, busy: bool) -> None:
+        self._mode = (label or "Chat").replace(" mode", "") or "Chat"
+        self._busy = busy
+        if busy and not self._timer.isActive():
+            self._timer.start()
+        elif not busy and self._timer.isActive():
+            self._timer.stop(); self._angle = 0
+        self.updateGeometry(); self.update()
+
+    def set_model(self, name: str, connected: bool) -> None:
+        """name='' → 'no model'; name + connected → green; name + not connected → amber."""
+        self._model_name = name or ""
+        self._model_ok = bool(connected)
+        self.setToolTip("Local model connected — Wizard, Coach and open-ended Q&A are on."
+                        if (self._model_name and self._model_ok) else
+                        f"'{self._model_name}' is set but not responding — click to check Settings."
+                        if self._model_name else
+                        "No local model — click to connect one (Settings → LLM). Explain and "
+                        "build commands still work without it.")
+        self.updateGeometry(); self.update()
+
+    def set_enrolment(self, student: str, online: bool, due: int = 0) -> None:
+        """student='' → signed out (grey, and that is FINE); signed in + reachable → green with the
+        count of missions still due; signed in + unreachable → amber. `due < 0` = a TEACHER: no
+        assignments-due notion applies, so the pill shows the role instead of a count."""
+        self._student = student or ""
+        self._tc_ok = bool(online)
+        self._is_teacher = int(due) < 0
+        self._due = max(0, int(due))
+        if not self._student:
+            tip = ("Not signed in to a course. gBuilder works fully without one — click to enrol "
+                   "in a Teaching Center (Settings → Teaching Center).")
+        elif self._is_teacher:
+            tip = f"Signed in as {self._student} (teacher). Click for teacher tools."
+        elif not self._tc_ok:
+            tip = (f"Signed in as {self._student}, but the course server isn't reachable. "
+                   f"Showing your cached assignments; results will sync when it's back.")
+        elif self._due:
+            tip = (f"Signed in as {self._student} — {self._due} assigned mission"
+                   f"{'s' if self._due != 1 else ''} still to do. Click to open them.")
+        else:
+            tip = f"Signed in as {self._student} — nothing due. Click to browse missions."
+        self.setToolTip(tip)
+        self.updateGeometry(); self.update()
+
+    def _user_text(self) -> str:
+        if not self._student:
+            return "sign in"
+        if getattr(self, "_is_teacher", False):
+            return f"{self._student} · teacher"
+        if not self._tc_ok:
+            return f"{self._student} · offline"
+        return f"{self._student} · {self._due} due" if self._due else f"{self._student} · clear"
+
+    def _user_color(self) -> QColor:
+        t = self.theme.theme
+        if not self._student:
+            return QColor(t.muted)                       # signed out is not an error state
+        if not self._tc_ok:
+            return QColor(t.warning)
+        return QColor(t.accent) if self._due else QColor(t.success)
+
+    def _spin(self) -> None:
+        self._angle = (self._angle + 24) % 360
+        self.update()
+
+    # -- geometry ----------------------------------------------------------- #
+    def _font(self) -> QFont:
+        from .theme.manager import sp
+        f = QFont(); f.setPointSize(sp(9)); f.setBold(True)
+        return f
+
+    def _mode_color(self) -> QColor:
+        t = self.theme.theme
+        return {"Explain": QColor(t.accent), "Wizard": QColor(t.accent2),
+                "Coach": QColor(t.accent2), "Tutor": QColor(t.success)}.get(
+            self._mode, QColor(t.muted))
+
+    def _model_color(self) -> QColor:
+        t = self.theme.theme
+        if not self._model_name:
+            return QColor(t.muted)
+        return QColor(t.success) if self._model_ok else QColor(t.warning)
+
+    def _pills(self):
+        """(kind, text, colour, width) for each pill, left to right."""
+        fm = QFontMetrics(self._font())
+        t = self.theme.theme
+
+        def w(text):
+            return 30 + fm.horizontalAdvance(text)
+
+        model_txt = self._model_name or "no model"
+        act_txt = "Thinking…" if self._busy else "Idle"
+        act_col = QColor(t.warning) if self._busy else QColor(t.muted)
+        user_txt = self._user_text()
+        return [
+            ("mode", self._mode, self._mode_color(), w(self._mode)),
+            ("model", model_txt, self._model_color(), w(model_txt)),
+            ("activity", act_txt, act_col, w(act_txt)),
+            ("user", user_txt, self._user_color(), w(user_txt)),
+        ]
+
+    def _ranges(self) -> dict[str, tuple[float, float]]:
+        """Each pill's x-span. Derived from the layout, NOT recorded during paint — otherwise the
+        click targets don't exist until the widget has been painted once."""
+        out: dict[str, tuple[float, float]] = {}
+        x = 1.5
+        for kind, _t, _c, w in self._pills():
+            out[kind] = (x, x + w)
+            x += w + _GAP
+        return out
+
+    def sizeHint(self) -> QSize:
+        total = sum(p[3] for p in self._pills()) + _GAP * (len(self._pills()) - 1) + 3
+        return QSize(int(total), 26)
+
+    def minimumSizeHint(self) -> QSize:
+        return self.sizeHint()
+
+    # -- paint -------------------------------------------------------------- #
+    def _pill_bg(self, p: QPainter, x: float, w: float, col: QColor) -> None:
+        bg = QColor(col); bg.setAlpha(38)
+        p.setBrush(bg); p.setPen(QPen(col, 1.4))
+        p.drawRoundedRect(QRectF(x, 1.5, w, self.height() - 3), 12, 12)
+
+    def paintEvent(self, _e) -> None:
+        p = QPainter(self)
+        p.setRenderHint(QPainter.Antialiasing, True)
+        p.setFont(self._font())
+        h = self.height()
+        x = 1.5
+        for kind, text, col, w in self._pills():
+            self._pill_bg(p, x, w, col)
+            if kind == "activity" and self._busy:
+                p.save(); p.translate(x + 13, h / 2.0); p.rotate(self._angle)
+                pen = QPen(col, 2.4); pen.setCapStyle(Qt.RoundCap); p.setPen(pen)
+                p.drawArc(QRectF(-6, -6, 12, 12), 0, 290 * 16); p.restore()
+            elif kind == "user":
+                self._person(p, x + 13, h / 2.0, col)     # a person, not a status dot
+            else:
+                p.setBrush(col); p.setPen(Qt.NoPen)
+                p.drawEllipse(QRectF(x + 9, h / 2.0 - 4, 8, 8))
+            p.setPen(col)
+            p.drawText(QRectF(x + 22, 0, w - 20, h), Qt.AlignVCenter | Qt.AlignLeft, text)
+            x += w + _GAP
+        p.end()
+
+    def _person(self, p: QPainter, cx: float, cy: float, col: QColor) -> None:
+        """A little head-and-shoulders — the pill reads as YOU at a glance, not as another status
+        light. Hollow when signed out; filled once you're enrolled."""
+        p.save()
+        signed_in = bool(self._student)
+        p.setPen(QPen(col, 1.4))
+        p.setBrush(col if signed_in else Qt.NoBrush)
+        p.drawEllipse(QRectF(cx - 3.2, cy - 6.0, 6.4, 6.4))              # head
+        p.drawChord(QRectF(cx - 5.4, cy - 1.4, 10.8, 9.6), 0, 180 * 16)  # shoulders
+        p.restore()
+
+    # -- the Model and User pills are click targets -------------------------- #
+    def _hit(self, x: float) -> str:
+        for kind in ("model", "user"):
+            x0, x1 = self._ranges().get(kind, (0.0, 0.0))
+            if x0 <= x <= x1:
+                return kind
+        return ""
+
+    def mousePressEvent(self, e) -> None:
+        hit = self._hit(e.position().x())
+        if hit == "model":
+            self.model_clicked.emit()
+        elif hit == "user":
+            self.user_clicked.emit()
+        else:
+            super().mousePressEvent(e)
+
+    def mouseMoveEvent(self, e) -> None:
+        self.setCursor(Qt.PointingHandCursor if self._hit(e.position().x())
+                       else Qt.ArrowCursor)
+        super().mouseMoveEvent(e)

gini/ui/palette.py

@@ -0,0 +1,112 @@
+"""Searchable, categorized device palette. Items drag onto the canvas."""
+from __future__ import annotations
+
+from PySide6.QtCore import QMimeData, QSize, Qt, Signal
+from PySide6.QtGui import QDrag
+from PySide6.QtWidgets import (
+    QLineEdit, QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget,
+)
+
+from ..domain import by_category
+from .canvas import MIME
+from .theme import ThemeManager, icons
+
+KEY_ROLE = Qt.UserRole + 1
+
+
+class _Tree(QTreeWidget):
+    def __init__(self) -> None:
+        super().__init__()
+        self.setHeaderHidden(True)
+        self.setIndentation(10)
+        self.setRootIsDecorated(True)
+        self.setDragEnabled(True)
+        self.setIconSize(QSize(22, 22))
+        self.setExpandsOnDoubleClick(False)
+
+    def startDrag(self, actions) -> None:
+        item = self.currentItem()
+        if item is None:
+            return
+        key = item.data(0, KEY_ROLE)
+        if not key:
+            return
+        mime = QMimeData()
+        mime.setData(MIME, key.encode())
+        drag = QDrag(self)
+        drag.setMimeData(mime)
+        ic = item.icon(0)
+        if not ic.isNull():
+            drag.setPixmap(ic.pixmap(28, 28))
+        drag.exec(Qt.CopyAction)
+
+
+class Palette(QWidget):
+    element_selected = Signal(str)      # type_key clicked (for explain mode)
+
+    def __init__(self, theme: ThemeManager) -> None:
+        super().__init__()
+        self.setObjectName("Sidebar")
+        self.theme = theme
+        lay = QVBoxLayout(self)
+        lay.setContentsMargins(10, 12, 10, 10)
+        lay.setSpacing(8)
+
+        self.search = QLineEdit()
+        self.search.setPlaceholderText("Search devices…")
+        self.search.addAction(
+            icons.icon("search", theme.theme.faint, 16),
+            QLineEdit.LeadingPosition,
+        )
+        self.search.textChanged.connect(self._filter)
+        lay.addWidget(self.search)
+
+        self.tree = _Tree()
+        self.tree.itemClicked.connect(self._on_item_clicked)
+        lay.addWidget(self.tree, 1)
+        self._populate()
+        theme.themeChanged.connect(self._restyle)
+
+    def _on_item_clicked(self, item, _col) -> None:
+        key = item.data(0, KEY_ROLE)
+        if key:
+            self.element_selected.emit(key)
+
+    def _populate(self) -> None:
+        self.tree.clear()
+        t = self.theme.theme
+        for cat, items in by_category().items():
+            top = QTreeWidgetItem([cat.value])
+            top.setFlags(Qt.ItemIsEnabled)
+            from .theme.manager import sp
+            f = top.font(0); f.setPointSize(sp(10)); f.setBold(True); top.setFont(0, f)
+            self.tree.addTopLevelItem(top)
+            top.setExpanded(True)
+            for d in items:
+                child = QTreeWidgetItem([d.label])
+                child.setData(0, KEY_ROLE, d.key)
+                child.setIcon(0, icons.icon(d.icon, t.accent_for(d.accent.value), 22))
+                child.setToolTip(0, d.description)
+                top.addChild(child)
+
+    def _filter(self, text: str) -> None:
+        text = text.strip().lower()
+        for i in range(self.tree.topLevelItemCount()):
+            top = self.tree.topLevelItem(i)
+            visible_children = 0
+            for j in range(top.childCount()):
+                ch = top.child(j)
+                show = text in ch.text(0).lower() or text in (ch.toolTip(0) or "").lower()
+                ch.setHidden(bool(text) and not show)
+                visible_children += 0 if ch.isHidden() else 1
+            top.setHidden(bool(text) and visible_children == 0)
+            if text:
+                top.setExpanded(True)
+
+    def _restyle(self, _name: str) -> None:
+        self._populate()
+        self.search.actions() and self.search.removeAction(self.search.actions()[0])
+        self.search.addAction(
+            icons.icon("search", self.theme.theme.faint, 16),
+            QLineEdit.LeadingPosition,
+        )

gini/ui/peripherals.py

@@ -0,0 +1,218 @@
+"""xv6 Terminal — the console as a single software peripheral you wire on the canvas.
+
+xv6 has no networking, so instead of switches/routers you attach peripherals to the Machine.
+The **Terminal** is the console: one shell view (a screen and keyboard in one, like a real tty),
+because xv6's console is a single bidirectional UART. Double-clicking a Terminal on the canvas
+opens this view, bound to its linked xv6 Machine's live provider.
+
+It talks to the same provider the Machine Lab uses. Output STREAMS in append-only via
+`console_since(cursor)` (so kernel output interleaves with your echoed input exactly like a real
+terminal); input goes out via `send_input()`. A few conveniences are handled terminal-side — the
+kind of thing a real terminal + readline do for you, not the shell: up/down-arrow command history,
+and the built-ins `help`, `clear`, `history`, and `ps` (xv6 has no `ps` program — it's Ctrl-P,
+which we surface under a friendly name). Everything else is passed straight to xv6's real `sh`.
+"""
+from __future__ import annotations
+
+from PySide6.QtCore import Qt, QTimer, Signal
+from PySide6.QtWidgets import (
+    QDialog, QHBoxLayout, QLabel, QLineEdit, QPlainTextEdit, QPushButton, QVBoxLayout,
+)
+
+from .theme import ThemeManager
+from .theme.manager import scale_css as _scss
+
+# terminal-side built-ins (handled here, not sent to xv6 sh) and the common real xv6 programs the
+# `help` text advertises — so students know what they can actually run.
+_BUILTINS = ("help", "clear", "history", "ps")
+_XV6_PROGRAMS = ("ls", "cat", "echo", "grep", "wc", "mkdir", "rm", "ln", "kill",
+                 "spin [secs]", "busy [secs]", "alloc", "writer", "forktest", "grind", "usertests")
+
+
+class TerminalView(QDialog):
+    """A bash-like console for an xv6 Machine: streaming output + a prompt line with history."""
+
+    delta_ready = Signal(str, int)           # (new console text, new cursor)
+
+    def __init__(self, parent, theme: ThemeManager, provider, device=None) -> None:
+        super().__init__(parent)
+        self.theme = theme
+        self.provider = provider
+        self._cursor = 0                      # console byte offset we've displayed up to
+        self._fetching = False               # one console read in flight — never overlap them
+        self._history: list[str] = []
+        self._hist_idx = 0                    # points one past the last entry (i.e. "new line")
+        t = theme.theme
+        self.setWindowTitle(f"Terminal — {getattr(device, 'name', 'xv6')}")
+        self.resize(760, 480)
+        self.setStyleSheet(f"QDialog{{background:{t.bg};}}")
+        v = QVBoxLayout(self)
+        v.setSpacing(6)
+        self.view = QPlainTextEdit()
+        self.view.setReadOnly(True)
+        self.view.setStyleSheet(
+            f"QPlainTextEdit{{background:{t.panel};color:{t.text};border:1px solid {t.line};"
+            "border-radius:6px;font-family:monospace;font-size:12px;}")
+        v.addWidget(self.view, 1)
+        # prompt row: a "$" marker + the input line, styled as one terminal strip
+        row = QHBoxLayout()
+        row.setSpacing(6)
+        prompt = QLabel("$")
+        prompt.setStyleSheet(_scss(f"color:{t.accent};font-family:monospace;font-size:13px;"))
+        row.addWidget(prompt)
+        self.input = QLineEdit()
+        self.input.setPlaceholderText("type a command — e.g.  spin 10 &   ·   ls   ·   help")
+        self.input.setStyleSheet(
+            f"QLineEdit{{background:{t.panel};color:{t.text};border:1px solid {t.line};"
+            "border-radius:6px;padding:8px;font-family:monospace;font-size:13px;}")
+        self.input.returnPressed.connect(self._submit)
+        self.input.installEventFilter(self)          # up/down = history
+        row.addWidget(self.input, 1)
+        # xv6 has no Ctrl-C / SIGINT, so a foreground program (e.g. `spin` with no &) blocks the
+        # shell. Break kills the most-recent user process via the kernel's console handler, so the
+        # prompt comes back even though sh isn't reading input.
+        brk = QPushButton("Break  ⌃C")
+        brk.setToolTip("Interrupt a hung foreground command (xv6 has no Ctrl-C — this kills the "
+                       "most-recently started program so the shell prompt returns)")
+        # CRITICAL: a dialog push button is auto-default, so Enter in the input line would ALSO
+        # click it — every submitted command would fire a Break and kill a process. Opt out so
+        # Enter only submits.
+        brk.setAutoDefault(False)
+        brk.setDefault(False)
+        brk.setStyleSheet(
+            f"QPushButton{{color:{t.text};background:{t.panel2};border:1px solid {t.line};"
+            f"border-radius:6px;padding:6px 12px;font-family:monospace;}}"
+            f"QPushButton:hover{{border-color:{t.accent};}}")
+        brk.clicked.connect(self._break)
+        self._break_btn = brk
+        row.addWidget(brk)
+        v.addLayout(row)
+        hint = QLabel("Programs take arguments (spin 10 & runs 10s in the background); ↑ recalls "
+                      "history; type help to see what you can run.")
+        hint.setStyleSheet(_scss(f"color:{t.faint};font-size:11px;"))
+        v.addWidget(hint)
+        self._streaming = hasattr(provider, "console_since")
+        self.delta_ready.connect(self._append_stream)
+        self._poll = QTimer(self)
+        self._poll.timeout.connect(self._refresh)
+        self._poll.start(350)
+        self.input.setFocus()
+        self._append("Connected. Type help to get started.\n")
+        self._refresh()
+
+    # -- output --------------------------------------------------------------- #
+    def _bg(self, fn):
+        import threading
+        threading.Thread(target=fn, daemon=True).start()
+
+    def _refresh(self):
+        # Never overlap reads: a slow agent + a fixed timer would stack background reads that all
+        # fetch from the SAME cursor, duplicating output (and echoed commands). One in flight only.
+        if self._fetching:
+            return
+        self._fetching = True
+        cur = self._cursor
+        def work():
+            try:
+                if self._streaming:
+                    text, nxt = self.provider.console_since(cur)
+                else:                                # provider without streaming -> full tail
+                    text, nxt = "\x00" + (self.provider.console() or ""), cur
+            except Exception:
+                text, nxt = "", cur                  # a failed read: skip, keep what we have
+            self.delta_ready.emit(text, nxt)
+        self._bg(work)
+
+    def _append_stream(self, text: str, nxt: int):
+        self._fetching = False                       # read done — the next tick may fetch again
+        self._cursor = nxt                           # advance the cursor on the GUI thread (safe)
+        if text.startswith("\x00"):                  # non-streaming fallback: replace the pane
+            body = text[1:]
+            if body and body != self.view.toPlainText():
+                self._set_text(body)
+            return
+        if text:
+            self._append(text)
+
+    def _append(self, text: str):
+        sb = self.view.verticalScrollBar()
+        at_bottom = sb.value() >= sb.maximum() - 4
+        cur = self.view.textCursor()
+        cur.movePosition(cur.MoveOperation.End)
+        cur.insertText(text)
+        if at_bottom:
+            sb.setValue(sb.maximum())
+
+    def _set_text(self, text: str):
+        sb = self.view.verticalScrollBar()
+        at_bottom = sb.value() >= sb.maximum() - 4
+        self.view.setPlainText(text)
+        if at_bottom:
+            sb.setValue(sb.maximum())
+
+    # -- input ---------------------------------------------------------------- #
+    def _submit(self):
+        cmd = self.input.text().strip()
+        self.input.clear()
+        if cmd:
+            self._history.append(cmd)
+        self._hist_idx = len(self._history)
+        if cmd in _BUILTINS:
+            self._builtin(cmd)                       # handled terminal-side, echoed locally
+            return
+        # a real xv6 command: xv6's console echoes it back, so it appears in the stream itself
+        self._bg(lambda: self.provider.send_input(cmd + "\n"))
+
+    def _builtin(self, cmd: str):
+        self._append(f"$ {cmd}\n")                   # local echo (xv6 never sees these)
+        if cmd == "help":
+            self._append(self._help_text())
+        elif cmd == "clear":
+            if hasattr(self.provider, "clear_console"):
+                self._bg(self.provider.clear_console)
+            self.view.clear()
+        elif cmd == "history":
+            for i, h in enumerate(self._history, 1):
+                self._append(f"{i:>4}  {h}\n")
+        elif cmd == "ps":
+            # xv6 has no `ps` program — Ctrl-P triggers the kernel's native procdump, which prints
+            # to the console and streams back in like any other output.
+            self._append("(xv6 process table — Ctrl-P)\n")
+            self._bg(lambda: self.provider.send_input("\x10"))
+
+    def _break(self):
+        # send the kernel's break control-char (Ctrl-C). The console driver handles it directly —
+        # NOT sh — so it works even while a foreground program has the shell blocked in wait().
+        self._append("^C\n")
+        if hasattr(self.provider, "interrupt"):
+            self._bg(self.provider.interrupt)
+        else:                                        # older provider: fall back to raw Ctrl-C
+            self._bg(lambda: self.provider.send_input("\x03"))
+
+    def _help_text(self) -> str:
+        return (
+            "terminal built-ins: " + ", ".join(_BUILTINS) + "\n"
+            "xv6 programs:       " + ", ".join(_XV6_PROGRAMS) + "\n"
+            "tips: add & to run in the background (spin 10 &); ↑/↓ recall history; "
+            "programs take arguments.\n")
+
+    def eventFilter(self, obj, ev):  # noqa: N802
+        if obj is self.input and ev.type() == ev.Type.KeyPress:
+            if ev.key() == Qt.Key_Up:
+                self._recall(-1)
+                return True
+            if ev.key() == Qt.Key_Down:
+                self._recall(+1)
+                return True
+        return super().eventFilter(obj, ev)
+
+    def _recall(self, step: int):
+        if not self._history:
+            return
+        self._hist_idx = max(0, min(len(self._history), self._hist_idx + step))
+        self.input.setText(self._history[self._hist_idx] if self._hist_idx < len(self._history)
+                           else "")
+
+    def closeEvent(self, e):  # noqa: N802
+        self._poll.stop()
+        super().closeEvent(e)